From bc0ab6160eaa5875064bd467f222df2c007a568d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:20:47 +0200 Subject: [PATCH 01/11] regenerate against MEOS 1.3 stable release Refresh the vendored builder/meos.h against MEOS 1.3 stable (/tmp/meos-1.3 built from upstream/stable-1.3) and re-run the codegen pipeline. Picks up the public API additions and renames that landed between the previous 1.3.0a1 snapshot and the actual 1.3.0 release: rtree builders (intspan/bigintspan/floatspan/ datespan/tstzspan/tbox/stbox + rtree_free/insert/search), the type-specific box helpers (tfloatbox_expand/shift_scale, tintbox_expand/shift_scale replacing tbox_expand/shift_scale suffixed by float/int), span expand split (intspan_expand and floatspan_expand replacing numspan_expand), tbox_hash and tbox_hash_extended, temporal_segm_duration, tnumber_avg_value, tnumber_trend, temporal_before/after_timestamptz, text_in, float8_out, int32_cmp, int64_cmp, plus geo helpers (box3d_make/ out, gbox_make, geo_points, geo_pointarr, geom_intersection2d_coll, geom_min_bounding_radius). Drops geog_from_binary. Signature changes: minus_date_date now returns int (was Interval *), several helpers take const qualifiers (geo_transform, geom_buffer, geom_unary_union), and the geo_geoN -> geo_geo_n rename. textset_make_modifier extended to handle both `const text **` and `text **` parameter shapes since MEOS 1.3 dropped the const qualifier on textset_make's values pointer. Version bumped to 1.3.0a2. --- builder/build_pymeos_functions_modifiers.py | 7 +- builder/meos.h | 223 ++++-- pymeos_cffi/__init__.py | 99 ++- pymeos_cffi/functions.py | 764 ++++++++++++++++---- 4 files changed, 840 insertions(+), 253 deletions(-) diff --git a/builder/build_pymeos_functions_modifiers.py b/builder/build_pymeos_functions_modifiers.py index df851e1..9db92ba 100644 --- a/builder/build_pymeos_functions_modifiers.py +++ b/builder/build_pymeos_functions_modifiers.py @@ -29,8 +29,11 @@ def custom_array_modifier(function: str) -> str: def textset_make_modifier(function: str) -> str: function = array_parameter_modifier("values", "count")(function) - return function.replace("_ffi.cast('const text *', x)", "cstring2text(x)").replace( - "'list[const text]'", "list[str]" + return ( + function.replace("_ffi.cast('const text *', x)", "cstring2text(x)") + .replace("_ffi.cast('text *', x)", "cstring2text(x)") + .replace("'list[const text]'", "list[str]") + .replace("'list[text]'", "list[str]") ) diff --git a/builder/meos.h b/builder/meos.h index 07baee7..4066b3f 100644 --- a/builder/meos.h +++ b/builder/meos.h @@ -202,30 +202,21 @@ typedef struct int j; } Match; -#define SKIPLIST_MAXLEVEL 32 -typedef struct -{ - void *value; - int height; - int next[SKIPLIST_MAXLEVEL]; -} SkipListElem; - -typedef struct -{ - int capacity; - int next; - int length; - int *freed; - int freecount; - int freecap; - int tail; - void *extra; - size_t extrasize; - SkipListElem *elems; -} SkipList; +typedef struct SkipList SkipList; typedef struct RTree RTree; +extern RTree *rtree_create_intspan(); +extern RTree *rtree_create_bigintspan(); +extern RTree *rtree_create_floatspan(); +extern RTree *rtree_create_datespan(); +extern RTree *rtree_create_tstzspan(); +extern RTree *rtree_create_tbox(); +extern RTree *rtree_create_stbox(); +extern void rtree_free(RTree *rtree); +extern void rtree_insert(RTree *rtree, void *box, int64 id); +extern int *rtree_search(const RTree *rtree,const void *query, int *count); + typedef enum { MEOS_SUCCESS = 0, @@ -291,9 +282,12 @@ extern TimestampTz date_to_timestamptz(DateADT d); extern double float_exp(double d); extern double float_ln(double d); extern double float_log10(double d); +extern char *float8_out(double d, int maxdd); extern double float_round(double d, int maxdd); +extern int int32_cmp(int32 l, int32 r); +extern int int64_cmp(int64 l, int64 r); extern Interval *interval_make(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, double secs); -extern Interval *minus_date_date(DateADT d1, DateADT d2); +extern int 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); @@ -310,6 +304,7 @@ 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_in(const char *str); extern text *text_initcap(const text *txt); extern text *text_lower(const text *txt); extern char *text_out(const text *txt); @@ -321,6 +316,7 @@ extern DateADT timestamptz_to_date(TimestampTz t); extern Set *bigintset_in(const char *str); extern char *bigintset_out(const Set *set); +extern Span *bigintspan_expand(const Span *s, int64 value); extern Span *bigintspan_in(const char *str); extern char *bigintspan_out(const Span *s); extern SpanSet *bigintspanset_in(const char *str); @@ -333,12 +329,14 @@ extern SpanSet *datespanset_in(const char *str); extern char *datespanset_out(const SpanSet *ss); extern Set *floatset_in(const char *str); extern char *floatset_out(const Set *set, int maxdd); +extern Span *floatspan_expand(const Span *s, double value); extern Span *floatspan_in(const char *str); extern char *floatspan_out(const Span *s, int maxdd); extern SpanSet *floatspanset_in(const char *str); extern char *floatspanset_out(const SpanSet *ss, int maxdd); extern Set *intset_in(const char *str); extern char *intset_out(const Set *set); +extern Span *intspan_expand(const Span *s, int32 value); extern Span *intspan_in(const char *str); extern char *intspan_out(const Span *s); extern SpanSet *intspanset_in(const char *str); @@ -376,7 +374,7 @@ 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); -extern Set *textset_make(const text **values, int count); +extern Set *textset_make(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); @@ -518,7 +516,6 @@ extern SpanSet *floatspanset_shift_scale(const SpanSet *ss, double shift, double 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 Span *numspan_expand(const Span *s, Datum value); extern Span *tstzspan_expand(const Span *s, const Interval *interv); extern Set *set_round(const Set *s, int maxdd); extern Set *textcat_text_textset(const text *txt, const Set *s); @@ -974,6 +971,8 @@ extern Span *tbox_to_floatspan(const TBox *box); extern Span *tbox_to_tstzspan(const TBox *box); extern TBox *timestamptz_to_tbox(TimestampTz t); +extern uint32 tbox_hash(const TBox *box); +extern uint64 tbox_hash_extended(const TBox *box, uint64 seed); extern bool tbox_hast(const TBox *box); extern bool tbox_hasx(const TBox *box); extern bool tbox_tmax(const TBox *box, TimestampTz *result); @@ -989,13 +988,13 @@ extern bool tboxfloat_xmin(const TBox *box, double *result); extern bool tboxint_xmax(const TBox *box, int *result); extern bool tboxint_xmin(const TBox *box, int *result); -extern TBox *tbox_expand_float(const TBox *box, double d); -extern TBox *tbox_expand_int(const TBox *box, int i); extern TBox *tbox_expand_time(const TBox *box, const Interval *interv); extern TBox *tbox_round(const TBox *box, int maxdd); -extern TBox *tbox_shift_scale_float(const TBox *box, double shift, double width, bool hasshift, bool haswidth); -extern TBox *tbox_shift_scale_int(const TBox *box, int shift, int width, bool hasshift, bool haswidth); extern TBox *tbox_shift_scale_time(const TBox *box, const Interval *shift, const Interval *duration); +extern TBox *tfloatbox_expand(const TBox *box, double d); +extern TBox *tfloatbox_shift_scale(const TBox *box, double shift, double width, bool hasshift, bool haswidth); +extern TBox *tintbox_expand(const TBox *box, int i); +extern TBox *tintbox_shift_scale(const TBox *box, int shift, int width, bool hasshift, bool haswidth); extern TBox *union_tbox_tbox(const TBox *box1, const TBox *box2, bool strict); extern TBox *intersection_tbox_tbox(const TBox *box1, const TBox *box2); @@ -1057,9 +1056,9 @@ extern TInstant *tintinst_make(int i, TimestampTz t); extern TSequence *tintseq_from_base_tstzset(int i, const Set *s); extern TSequence *tintseq_from_base_tstzspan(int i, const Span *s); extern TSequenceSet *tintseqset_from_base_tstzspanset(int i, const SpanSet *ss); -extern TSequence *tsequence_make(const TInstant **instants, int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); -extern TSequenceSet *tsequenceset_make(const TSequence **sequences, int count, bool normalize); -extern TSequenceSet *tsequenceset_make_gaps(const TInstant **instants, int count, interpType interp, const Interval *maxt, double maxdist); +extern TSequence *tsequence_make(TInstant **instants, int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequenceSet *tsequenceset_make(TSequence **sequences, int count, bool normalize); +extern TSequenceSet *tsequenceset_make_gaps(TInstant **instants, int count, interpType interp, const Interval *maxt, double maxdist); extern Temporal *ttext_from_base_temp(const text *txt, const Temporal *temp); extern TInstant *ttextinst_make(const text *txt, TimestampTz t); extern TSequence *ttextseq_from_base_tstzset(const text *txt, const Set *s); @@ -1092,6 +1091,7 @@ 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 TSequenceSet *temporal_segm_duration(const Temporal *temp, const Interval *duration, bool atleast, bool strict); 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); @@ -1104,9 +1104,10 @@ extern SpanSet *temporal_time(const Temporal *temp); extern TimestampTz *temporal_timestamps(const Temporal *temp, int *count); extern bool temporal_timestamptz_n(const Temporal *temp, int n, TimestampTz *result); extern bool temporal_upper_inc(const Temporal *temp); +/* extern double tfloat_avg_value(const Temporal *temp); (undefined) */ 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_max_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 bool tfloat_value_n(const Temporal *temp, int n, double *result); @@ -1118,6 +1119,7 @@ extern int tint_start_value(const Temporal *temp); extern bool tint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, int *value); extern bool tint_value_n(const Temporal *temp, int n, int *result); extern int *tint_values(const Temporal *temp, int *count); +extern double tnumber_avg_value(const Temporal *temp); extern double tnumber_integral(const Temporal *temp); extern double tnumber_twavg(const Temporal *temp); extern SpanSet *tnumber_valuespans(const Temporal *temp); @@ -1130,7 +1132,7 @@ extern bool ttext_value_n(const Temporal *temp, int n, text **result); extern text **ttext_values(const Temporal *temp, int *count); extern double float_degrees(double value, bool normalize); -extern Temporal **temparr_round(const Temporal **temp, int count, int maxdd); +extern Temporal **temparr_round(Temporal **temp, int count, int maxdd); extern Temporal *temporal_round(const Temporal *temp, int maxdd); extern Temporal *temporal_scale_time(const Temporal *temp, const Interval *duration); extern Temporal *temporal_set_interp(const Temporal *temp, interpType interp); @@ -1158,11 +1160,12 @@ extern Temporal *temporal_delete_tstzspan(const Temporal *temp, const Span *s, b extern Temporal *temporal_delete_tstzspanset(const Temporal *temp, const SpanSet *ss, bool connect); extern Temporal *temporal_insert(const Temporal *temp1, const Temporal *temp2, bool connect); extern Temporal *temporal_merge(const Temporal *temp1, const Temporal *temp2); -extern Temporal *temporal_merge_array(const Temporal **temparr, int count); +extern Temporal *temporal_merge_array(Temporal **temparr, int count); extern Temporal *temporal_update(const Temporal *temp1, const Temporal *temp2, bool connect); extern Temporal *tbool_at_value(const Temporal *temp, bool b); extern Temporal *tbool_minus_value(const Temporal *temp, bool b); +extern Temporal *temporal_after_timestamptz(const Temporal *temp, TimestampTz t, bool strict); extern Temporal *temporal_at_max(const Temporal *temp); extern Temporal *temporal_at_min(const Temporal *temp); extern Temporal *temporal_at_timestamptz(const Temporal *temp, TimestampTz t); @@ -1170,6 +1173,7 @@ extern Temporal *temporal_at_tstzset(const Temporal *temp, const Set *s); extern Temporal *temporal_at_tstzspan(const Temporal *temp, const Span *s); extern Temporal *temporal_at_tstzspanset(const Temporal *temp, const SpanSet *ss); extern Temporal *temporal_at_values(const Temporal *temp, const Set *set); +extern Temporal *temporal_before_timestamptz(const Temporal *temp, TimestampTz t, bool strict); extern Temporal *temporal_minus_max(const Temporal *temp); extern Temporal *temporal_minus_min(const Temporal *temp); extern Temporal *temporal_minus_timestamptz(const Temporal *temp, TimestampTz t); @@ -1465,6 +1469,7 @@ extern Temporal *tfloat_exp(const Temporal *temp); extern Temporal *tfloat_ln(const Temporal *temp); extern Temporal *tfloat_log10(const Temporal *temp); extern Temporal *tnumber_abs(const Temporal *temp); +extern Temporal *tnumber_trend(const Temporal *temp); extern double float_angular_difference(double degrees1, double degrees2); extern Temporal *tnumber_angular_difference(const Temporal *temp); extern Temporal *tnumber_delta_value(const Temporal *temp); @@ -1625,9 +1630,9 @@ typedef enum T_TGEOMETRY = 60, T_TGEOGRAPHY = 61, T_TRGEOMETRY = 62, + NO_MEOS_TYPES } meosType; -#define NO_MEOS_TYPES 63 typedef enum { UNKNOWN_OP = 0, @@ -2159,12 +2164,19 @@ extern GSERIALIZED *geo_from_ewkb(const uint8_t *wkb, size_t wkb_size, int32 sri extern GSERIALIZED *geo_from_geojson(const char *geojson); extern GSERIALIZED *geo_from_text(const char *wkt, int32_t srid); extern char *geo_out(const GSERIALIZED *gs); -extern GSERIALIZED *geog_from_binary(const char *wkb_bytea); +/* extern GSERIALIZED *geog_from_binary(const char *wkb_bytea); (undefined) */ extern GSERIALIZED *geog_from_hexewkb(const char *wkt); extern GSERIALIZED *geog_in(const char *str, int32 typmod); extern GSERIALIZED *geom_from_hexewkb(const char *wkt); extern GSERIALIZED *geom_in(const char *str, int32 typmod); +extern BOX3D *box3d_make(double xmin, double xmax, double ymin, double ymax, + double zmin, double zmax, int32_t srid); +extern char *box3d_out(const BOX3D *box, int maxdd); +extern GBOX *gbox_make(bool hasz, double xmin, double xmax, double ymin, + double ymax, double zmin, double zmax); +extern char *gbox_out(const GBOX *box, int maxdd); + extern GSERIALIZED *geo_copy(const GSERIALIZED *g); extern GSERIALIZED *geogpoint_make2d(int32_t srid, double x, double y); extern GSERIALIZED *geogpoint_make3dz(int32_t srid, double x, double y, double z); @@ -2175,8 +2187,7 @@ extern GSERIALIZED *geom_to_geog(const GSERIALIZED *geom); extern GSERIALIZED *geog_to_geom(const GSERIALIZED *geog); extern bool geo_is_empty(const GSERIALIZED *g); -/* extern bool geo_is_unitary(const GSERIALIZED *gs); (undefined) */ - +extern bool geo_is_unitary(const GSERIALIZED *gs); extern const char *geo_typename(int type); extern double geog_area(const GSERIALIZED *g, bool use_spheroid); extern GSERIALIZED *geog_centroid(const GSERIALIZED *g, bool use_spheroid); @@ -2193,31 +2204,29 @@ extern GSERIALIZED *geo_round(const GSERIALIZED *gs, int maxdd); extern GSERIALIZED *geo_set_srid(const GSERIALIZED *gs, int32_t srid); extern int32_t geo_srid(const GSERIALIZED *gs); -extern GSERIALIZED *geo_transform(GSERIALIZED *geom, int32_t srid_to); +extern GSERIALIZED *geo_transform(const GSERIALIZED *geom, int32_t srid_to); extern GSERIALIZED *geo_transform_pipeline(const GSERIALIZED *gs, char *pipeline, int32_t srid_to, bool is_forward); extern GSERIALIZED *geo_collect_garray(GSERIALIZED **gsarr, int count); extern GSERIALIZED *geo_makeline_garray(GSERIALIZED **gsarr, int count); -extern int geo_npoints(const GSERIALIZED *gs); -extern int geo_ngeos(const GSERIALIZED *gs); -extern GSERIALIZED *geo_geoN(const GSERIALIZED *geom, int n); -/* extern GSERIALIZED **geo_pointarr(const GSERIALIZED *gs, int *count); (undefined) */ -/* extern GSERIALIZED *geo_points(const GSERIALIZED *gs); (undefined) */ - +extern int geo_num_points(const GSERIALIZED *gs); +extern int geo_num_geos(const GSERIALIZED *gs); +extern GSERIALIZED *geo_geo_n(const GSERIALIZED *geom, int n); +extern GSERIALIZED **geo_pointarr(const GSERIALIZED *gs, int *count); +extern GSERIALIZED *geo_points(const GSERIALIZED *gs); extern GSERIALIZED *geom_array_union(GSERIALIZED **gsarr, int count); extern GSERIALIZED *geom_boundary(const GSERIALIZED *gs); -extern GSERIALIZED *geom_buffer(const GSERIALIZED *gs, double size, char *params); +extern GSERIALIZED *geom_buffer(const GSERIALIZED *gs, double size, const char *params); extern GSERIALIZED *geom_centroid(const GSERIALIZED *gs); extern GSERIALIZED *geom_convex_hull(const GSERIALIZED *gs); extern GSERIALIZED *geom_difference2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); extern GSERIALIZED *geom_intersection2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); -/* extern GSERIALIZED *geom_intersection2d_coll(const GSERIALIZED *gs1, const GSERIALIZED *gs2); (undefined) */ -/* extern GSERIALIZED *geom_min_bounding_radius(const GSERIALIZED *geom, double *radius); (undefined) */ - +extern GSERIALIZED *geom_intersection2d_coll(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *geom_min_bounding_radius(const GSERIALIZED *geom, double *radius); extern GSERIALIZED *geom_shortestline2d(const GSERIALIZED *gs1, const GSERIALIZED *s2); extern GSERIALIZED *geom_shortestline3d(const GSERIALIZED *gs1, const GSERIALIZED *s2); -extern GSERIALIZED *geom_unary_union(GSERIALIZED *gs, double prec); -extern GSERIALIZED *line_interpolate_point(GSERIALIZED *gs, double distance_fraction, bool repeat); +extern GSERIALIZED *geom_unary_union(const GSERIALIZED *gs, double prec); +extern GSERIALIZED *line_interpolate_point(const GSERIALIZED *gs, double distance_fraction, bool repeat); extern double line_locate_point(const GSERIALIZED *gs1, const GSERIALIZED *gs2); extern GSERIALIZED *line_substring(const GSERIALIZED *gs, double from, double to); @@ -2249,7 +2258,7 @@ extern Set *geomset_in(const char *str); extern char *spatialset_as_text(const Set *set, int maxdd); extern char *spatialset_as_ewkt(const Set *set, int maxdd); -extern Set *geoset_make(const GSERIALIZED **values, int count); +extern Set *geoset_make(GSERIALIZED **values, int count); extern Set *geo_to_set(const GSERIALIZED *gs); @@ -2297,6 +2306,8 @@ extern STBox *tstzspan_to_stbox(const Span *s); extern STBox *tstzspanset_to_stbox(const SpanSet *ss); extern double stbox_area(const STBox *box, bool spheroid); +extern uint32 stbox_hash(const STBox *box); +extern uint64 stbox_hash_extended(const STBox *box, uint64 seed); extern bool stbox_hast(const STBox *box); extern bool stbox_hasx(const STBox *box); extern bool stbox_hasz(const STBox *box); @@ -2361,12 +2372,6 @@ extern bool stbox_le(const STBox *box1, const STBox *box2); extern bool stbox_lt(const STBox *box1, const STBox *box2); extern bool stbox_ne(const STBox *box1, const STBox *box2); -extern RTree *rtree_create_stbox(); -extern void rtree_free(RTree *rtree); -extern void rtree_insert(RTree *rtree, STBox *box, int64 id); -extern int *rtree_search(const RTree *rtree,const STBox *query, int *count); - -extern char *tgeo_out(const Temporal *temp, int maxdd); extern Temporal *tgeogpoint_from_mfjson(const char *str); extern Temporal *tgeogpoint_in(const char *str); extern Temporal *tgeography_from_mfjson(const char *mfjson); @@ -2377,6 +2382,7 @@ extern Temporal *tgeompoint_from_mfjson(const char *str); extern Temporal *tgeompoint_in(const char *str); extern char *tspatial_as_ewkt(const Temporal *temp, int maxdd); extern char *tspatial_as_text(const Temporal *temp, int maxdd); +extern char *tspatial_out(const Temporal *temp, int maxdd); extern Temporal *tgeo_from_base_temp(const GSERIALIZED *gs, const Temporal *temp); extern TInstant *tgeoinst_make(const GSERIALIZED *gs, TimestampTz t); @@ -2609,7 +2615,7 @@ extern Temporal **tgeo_space_split(const Temporal *temp, double xsize, double ys extern Temporal **tgeo_space_time_split(const Temporal *temp, double xsize, double ysize, double zsize, const Interval *duration, const GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, bool border_inc, GSERIALIZED ***space_bins, TimestampTz **time_bins, int *count); extern int *geo_cluster_kmeans(const GSERIALIZED **geoms, uint32_t ngeoms, uint32_t k); -extern uint32_t *geo_cluster_dbscan(const GSERIALIZED **geoms, uint32_t ngeoms, double tolerance, int minpoints); +extern uint32_t *geo_cluster_dbscan(const GSERIALIZED **geoms, uint32_t ngeoms, double tolerance, int minpoints, int *count); extern GSERIALIZED **geo_cluster_intersecting(const GSERIALIZED **geoms, uint32_t ngeoms, int *count); extern GSERIALIZED **geo_cluster_within(const GSERIALIZED **geoms, uint32_t ngeoms, double tolerance, int *count); @@ -2717,6 +2723,43 @@ extern GSERIALIZED **geo_cluster_within(const GSERIALIZED **geoms, uint32_t ngeo +#define SKIPLIST_MAXLEVEL 32 +typedef struct +{ + void *key; + void *value; + int height; + int next[SKIPLIST_MAXLEVEL]; +} SkipListElem; + +struct SkipList +{ + size_t key_size; + size_t value_size; + int capacity; + int length; + int next; + int tail; + int *freed; + int freecount; + int freecap; + void *extra; + size_t extrasize; + int (*comp_fn)(void *, void *); + void *(*merge_fn)(void *, void *); + SkipListElem *elems; +}; + +typedef enum +{ + TEMPORAL, + KEYVALUE +} SkipListType; + +typedef Datum (*datum_func1) (Datum); +typedef Datum (*datum_func2) (Datum, Datum); +typedef Datum (*datum_func3) (Datum, Datum, Datum); + extern gsl_rng *gsl_get_generation_rng(void); extern gsl_rng *gsl_get_aggregation_rng(void); @@ -2772,13 +2815,14 @@ extern void datespan_set_tstzspan(const Span *s1, Span *s2); 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); +extern Span *numspan_expand(const Span *s, Datum value); 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); extern void span_expand(const Span *s1, Span *s2); extern SpanSet *spanset_compact(const SpanSet *ss); extern TBox *tbox_expand_value(const TBox *box, Datum value, meosType basetyp); -extern Set *textcat_textset_text_int(const Set *s, const text *txt, bool invert); +extern Set *textcat_textset_text_common(const Set *s, const text *txt, bool invert); extern void tstzspan_set_datespan(const Span *s1, Span *s2); extern bool adjacent_span_value(const Span *s, Datum value); @@ -2818,6 +2862,14 @@ 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 bool bbox_type(meosType bboxtype); +extern size_t bbox_get_size(meosType bboxtype); +extern int bbox_max_dims(meosType bboxtype); +extern bool temporal_bbox_eq(const void *box1, const void *box2, + meosType temptype); +extern int temporal_bbox_cmp(const void *box1, const void *box2, + meosType temptype); + 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 value); @@ -2880,7 +2932,7 @@ extern TSequence *tboolseq_in(const char *str, interpType interp); 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 char **temparr_out(const Temporal **temparr, int count, int maxdd); +extern char **temparr_out(Temporal **temparr, int count, int maxdd); /* extern TInstant *tfloatinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *tfloatinst_in(const char *str); /* extern TSequence *tfloatseq_from_mfjson(json_object *mfjson, interpType interp); (undefined type json_object) */ @@ -2918,13 +2970,13 @@ extern TSequence *tsequence_copy(const TSequence *seq); extern TSequence *tsequence_from_base_temp(Datum value, meosType temptype, const TSequence *seq); extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *s); 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_exp(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_copy(const TSequenceSet *ss); extern TSequenceSet *tseqsetarr_to_tseqset(TSequenceSet **seqsets, int count, int totalseqs); extern TSequenceSet *tsequenceset_from_base_temp(Datum value, meosType temptype, const TSequenceSet *ss); 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_exp(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); @@ -2939,9 +2991,11 @@ extern void tsequenceset_set_tstzspan(const TSequenceSet *ss, Span *s); extern const TInstant *temporal_end_inst(const Temporal *temp); extern Datum temporal_end_value(const Temporal *temp); extern const TInstant *temporal_inst_n(const Temporal *temp, int n); -extern const TInstant **temporal_instants_p(const Temporal *temp, int *count); +extern const TInstant **temporal_insts_p(const Temporal *temp, int *count); +extern const TInstant *temporal_max_inst_p(const Temporal *temp); extern Datum temporal_max_value(const Temporal *temp); extern size_t temporal_mem_size(const Temporal *temp); +extern const TInstant *temporal_min_inst_p(const Temporal *temp); extern Datum temporal_min_value(const Temporal *temp); extern const TSequence **temporal_sequences_p(const Temporal *temp, int *count); extern void temporal_set_bbox(const Temporal *temp, void *box); @@ -2961,15 +3015,17 @@ extern bool tinstant_value_at_timestamptz(const TInstant *inst, TimestampTz t, D extern Datum *tinstant_values_p(const TInstant *inst, int *count); extern void tnumber_set_span(const Temporal *temp, Span *span); extern SpanSet *tnumberinst_valuespans(const TInstant *inst); +extern double tnumberseq_avg_val(const TSequence *seq); extern SpanSet *tnumberseq_valuespans(const TSequence *seq); +extern double tnumberseqset_avg_val(const TSequenceSet *ss); 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_insts_p(const TSequence *seq); -extern const TInstant *tsequence_max_inst(const TSequence *seq); +extern const TInstant *tsequence_max_inst_p(const TSequence *seq); extern Datum tsequence_max_val(const TSequence *seq); -extern const TInstant *tsequence_min_inst(const TSequence *seq); +extern const TInstant *tsequence_min_inst_p(const TSequence *seq); extern Datum tsequence_min_val(const TSequence *seq); extern TSequence **tsequence_segments(const TSequence *seq, int *count); extern const TSequence **tsequence_seqs(const TSequence *seq, int *count); @@ -2983,9 +3039,9 @@ 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_insts_p(const TSequenceSet *ss); -extern const TInstant *tsequenceset_max_inst(const TSequenceSet *ss); +extern const TInstant *tsequenceset_max_inst_p(const TSequenceSet *ss); extern Datum tsequenceset_max_val(const TSequenceSet *ss); -extern const TInstant *tsequenceset_min_inst(const TSequenceSet *ss); +extern const TInstant *tsequenceset_min_inst_p(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); @@ -3028,7 +3084,7 @@ 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 *tinstant_merge_array(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(const TSequence *seq1, const TSequence *seq2, bool expand); extern Temporal *tsequence_delete_timestamptz(const TSequence *seq, TimestampTz t, bool connect); @@ -3037,7 +3093,7 @@ extern Temporal *tsequence_delete_tstzspan(const TSequence *seq, const Span *s, 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 Temporal *tsequence_merge_array(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); @@ -3046,15 +3102,19 @@ extern TSequenceSet *tsequenceset_delete_tstzspan(const TSequenceSet *ss, const 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 TSequenceSet *tsequenceset_merge_array(TSequenceSet **seqsets, int count); extern void tsequence_expand_bbox(TSequence *seq, const TInstant *inst); extern void tsequence_set_bbox(const TSequence *seq, void *box); extern void tsequenceset_expand_bbox(TSequenceSet *ss, const TSequence *seq); extern void tsequenceset_set_bbox(const TSequenceSet *ss, void *box); -extern TSequence *tdiscseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); +extern TSequence *tcontseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tcontseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); extern TSequenceSet *tcontseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); +extern TSequence *tdiscseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_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_timestamptz(const Temporal *temp, TimestampTz t, bool atfunc); @@ -3064,6 +3124,8 @@ extern Temporal *temporal_restrict_tstzspanset(const Temporal *temp, const SpanS 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); +extern TInstant *tinstant_after_timestamptz(const TInstant *inst, TimestampTz t, bool strict); +extern TInstant *tinstant_before_timestamptz(const TInstant *inst, TimestampTz t, bool strict); extern TInstant *tinstant_restrict_tstzspan(const TInstant *inst, const Span *period, bool atfunc); extern TInstant *tinstant_restrict_tstzspanset(const TInstant *inst, const SpanSet *ss, bool atfunc); extern TInstant *tinstant_restrict_timestamptz(const TInstant *inst, TimestampTz t, bool atfunc); @@ -3079,6 +3141,8 @@ extern TSequenceSet *tnumberseqset_restrict_spanset(const TSequenceSet *ss, cons extern TInstant *tsequence_at_timestamptz(const TSequence *seq, TimestampTz t); 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 TSequenceSet *tsequenceset_after_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict); +extern TSequenceSet *tsequenceset_before_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict); 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); @@ -3142,7 +3206,16 @@ extern Temporal *temporal_compact(const Temporal *temp); extern TSequence *tsequence_compact(const TSequence *seq); extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); +extern SkipList *temporal_skiplist_make(); +extern SkipList *skiplist_make(size_t key_size, size_t value_size, + int (*comp_fn)(void *, void *), void *(*merge_fn)(void *, void *)); +extern int skiplist_search(SkipList *list, void *key, void *value); extern void skiplist_free(SkipList *list); +extern void skiplist_splice(SkipList *list, void **keys, void **values, int count, datum_func2 func, bool crossings, SkipListType sktype); +extern void temporal_skiplist_splice(SkipList *list, void **values, int count, datum_func2 func, bool crossings); +extern void **skiplist_values(SkipList *list); +extern void **skiplist_keys_values(SkipList *list, void **values); + extern Temporal *temporal_app_tinst_transfn(Temporal *state, const TInstant *inst, interpType interp, double maxdist, const Interval *maxt); extern Temporal *temporal_app_tseq_transfn(Temporal *state, const TSequence *seq); @@ -3323,7 +3396,7 @@ extern int64 nsegment_route(const Nsegment *ns); extern double nsegment_start_position(const Nsegment *ns); extern bool route_exists(int64 rid); -extern GSERIALIZED *route_geom(int64 rid); +extern const GSERIALIZED *route_geom(int64 rid); extern double route_length(int64 rid); extern Npoint *npoint_round(const Npoint *np, int maxdd); @@ -3355,7 +3428,7 @@ extern bool nsegment_ne(const Nsegment *ns1, const Nsegment *ns2); extern Set *npointset_in(const char *str); extern char *npointset_out(const Set *s, int maxdd); -extern Set *npointset_make(const Npoint **values, int count); +extern Set *npointset_make(Npoint **values, int count); extern Set *npoint_to_set(const Npoint *np); @@ -3366,7 +3439,7 @@ extern bool npointset_value_n(const Set *s, int n, Npoint **result); extern Npoint **npointset_values(const Set *s); extern bool contained_npoint_set(const Npoint *np, const Set *s); -extern bool contains_set_npoint(const Set *s, Npoint *np); +extern bool contains_set_npoint(const Set *s, const Npoint *np); extern Set *intersection_npoint_set(const Npoint *np, const Set *s); extern Set *intersection_set_npoint(const Set *s, const Npoint *np); extern Set *minus_npoint_set(const Npoint *np, const Set *s); diff --git a/pymeos_cffi/__init__.py b/pymeos_cffi/__init__.py index 61df1c6..2faed48 100644 --- a/pymeos_cffi/__init__.py +++ b/pymeos_cffi/__init__.py @@ -2,7 +2,7 @@ from .errors import * from .functions import * -__version__ = "1.3.0a1" +__version__ = "1.3.0a2" __all__ = [ # Exceptions "MeosException", @@ -62,6 +62,16 @@ "timestamp_out", "timestamptz_in", "timestamptz_out", + "rtree_create_intspan", + "rtree_create_bigintspan", + "rtree_create_floatspan", + "rtree_create_datespan", + "rtree_create_tstzspan", + "rtree_create_tbox", + "rtree_create_stbox", + "rtree_free", + "rtree_insert", + "rtree_search", "meos_errno", "meos_errno_set", "meos_errno_restore", @@ -86,7 +96,10 @@ "float_exp", "float_ln", "float_log10", + "float8_out", "float_round", + "int32_cmp", + "int64_cmp", "interval_make", "minus_date_date", "minus_date_int", @@ -105,6 +118,7 @@ "text2cstring", "text_cmp", "text_copy", + "text_in", "text_initcap", "text_lower", "text_out", @@ -115,6 +129,7 @@ "timestamptz_to_date", "bigintset_in", "bigintset_out", + "bigintspan_expand", "bigintspan_in", "bigintspan_out", "bigintspanset_in", @@ -127,12 +142,14 @@ "datespanset_out", "floatset_in", "floatset_out", + "floatspan_expand", "floatspan_in", "floatspan_out", "floatspanset_in", "floatspanset_out", "intset_in", "intset_out", + "intspan_expand", "intspan_in", "intspan_out", "intspanset_in", @@ -308,7 +325,6 @@ "intset_shift_scale", "intspan_shift_scale", "intspanset_shift_scale", - "numspan_expand", "tstzspan_expand", "set_round", "textcat_text_textset", @@ -752,6 +768,8 @@ "tbox_to_floatspan", "tbox_to_tstzspan", "timestamptz_to_tbox", + "tbox_hash", + "tbox_hash_extended", "tbox_hast", "tbox_hasx", "tbox_tmax", @@ -766,13 +784,13 @@ "tboxfloat_xmin", "tboxint_xmax", "tboxint_xmin", - "tbox_expand_float", - "tbox_expand_int", "tbox_expand_time", "tbox_round", - "tbox_shift_scale_float", - "tbox_shift_scale_int", "tbox_shift_scale_time", + "tfloatbox_expand", + "tfloatbox_shift_scale", + "tintbox_expand", + "tintbox_shift_scale", "union_tbox_tbox", "intersection_tbox_tbox", "adjacent_tbox_tbox", @@ -861,6 +879,7 @@ "temporal_num_instants", "temporal_num_sequences", "temporal_num_timestamps", + "temporal_segm_duration", "temporal_segments", "temporal_sequence_n", "temporal_sequences", @@ -874,8 +893,8 @@ "temporal_timestamptz_n", "temporal_upper_inc", "tfloat_end_value", - "tfloat_max_value", "tfloat_min_value", + "tfloat_max_value", "tfloat_start_value", "tfloat_value_at_timestamptz", "tfloat_value_n", @@ -887,6 +906,7 @@ "tint_value_at_timestamptz", "tint_value_n", "tint_values", + "tnumber_avg_value", "tnumber_integral", "tnumber_twavg", "tnumber_valuespans", @@ -929,6 +949,7 @@ "temporal_update", "tbool_at_value", "tbool_minus_value", + "temporal_after_timestamptz", "temporal_at_max", "temporal_at_min", "temporal_at_timestamptz", @@ -936,6 +957,7 @@ "temporal_at_tstzspan", "temporal_at_tstzspanset", "temporal_at_values", + "temporal_before_timestamptz", "temporal_minus_max", "temporal_minus_min", "temporal_minus_timestamptz", @@ -1223,6 +1245,7 @@ "tfloat_ln", "tfloat_log10", "tnumber_abs", + "tnumber_trend", "float_angular_difference", "tnumber_angular_difference", "tnumber_delta_value", @@ -1376,11 +1399,14 @@ "geo_from_geojson", "geo_from_text", "geo_out", - "geog_from_binary", "geog_from_hexewkb", "geog_in", "geom_from_hexewkb", "geom_in", + "box3d_make", + "box3d_out", + "gbox_make", + "gbox_out", "geo_copy", "geogpoint_make2d", "geogpoint_make3dz", @@ -1389,6 +1415,7 @@ "geom_to_geog", "geog_to_geom", "geo_is_empty", + "geo_is_unitary", "geo_typename", "geog_area", "geog_centroid", @@ -1407,9 +1434,11 @@ "geo_transform_pipeline", "geo_collect_garray", "geo_makeline_garray", - "geo_npoints", - "geo_ngeos", - "geo_geoN", + "geo_num_points", + "geo_num_geos", + "geo_geo_n", + "geo_pointarr", + "geo_points", "geom_array_union", "geom_boundary", "geom_buffer", @@ -1417,6 +1446,8 @@ "geom_convex_hull", "geom_difference2d", "geom_intersection2d", + "geom_intersection2d_coll", + "geom_min_bounding_radius", "geom_shortestline2d", "geom_shortestline3d", "geom_unary_union", @@ -1486,6 +1517,8 @@ "tstzspan_to_stbox", "tstzspanset_to_stbox", "stbox_area", + "stbox_hash", + "stbox_hash_extended", "stbox_hast", "stbox_hasx", "stbox_hasz", @@ -1543,11 +1576,6 @@ "stbox_le", "stbox_lt", "stbox_ne", - "rtree_create_stbox", - "rtree_free", - "rtree_insert", - "rtree_search", - "tgeo_out", "tgeogpoint_from_mfjson", "tgeogpoint_in", "tgeography_from_mfjson", @@ -1558,6 +1586,7 @@ "tgeompoint_in", "tspatial_as_ewkt", "tspatial_as_text", + "tspatial_out", "tgeo_from_base_temp", "tgeoinst_make", "tgeoseq_from_base_tstzset", @@ -1823,13 +1852,14 @@ "floatspan_set_intspan", "intspan_set_floatspan", "numset_shift_scale", + "numspan_expand", "numspan_shift_scale", "numspanset_shift_scale", "set_compact", "span_expand", "spanset_compact", "tbox_expand_value", - "textcat_textset_text_int", + "textcat_textset_text_common", "tstzspan_set_datespan", "adjacent_span_value", "adjacent_spanset_value", @@ -1866,6 +1896,11 @@ "right_value_spanset", "right_span_value", "right_spanset_value", + "bbox_type", + "bbox_get_size", + "bbox_max_dims", + "temporal_bbox_eq", + "temporal_bbox_cmp", "bbox_union_span_span", "inter_span_span", "intersection_set_value", @@ -1962,9 +1997,11 @@ "temporal_end_inst", "temporal_end_value", "temporal_inst_n", - "temporal_instants_p", + "temporal_insts_p", + "temporal_max_inst_p", "temporal_max_value", "temporal_mem_size", + "temporal_min_inst_p", "temporal_min_value", "temporal_sequences_p", "temporal_set_bbox", @@ -1984,15 +2021,17 @@ "tinstant_values_p", "tnumber_set_span", "tnumberinst_valuespans", + "tnumberseq_avg_val", "tnumberseq_valuespans", + "tnumberseqset_avg_val", "tnumberseqset_valuespans", "tsequence_duration", "tsequence_end_timestamptz", "tsequence_hash", "tsequence_insts_p", - "tsequence_max_inst", + "tsequence_max_inst_p", "tsequence_max_val", - "tsequence_min_inst", + "tsequence_min_inst_p", "tsequence_min_val", "tsequence_segments", "tsequence_seqs", @@ -2006,9 +2045,9 @@ "tsequenceset_hash", "tsequenceset_inst_n", "tsequenceset_insts_p", - "tsequenceset_max_inst", + "tsequenceset_max_inst_p", "tsequenceset_max_val", - "tsequenceset_min_inst", + "tsequenceset_min_inst_p", "tsequenceset_min_val", "tsequenceset_num_instants", "tsequenceset_num_timestamps", @@ -2072,8 +2111,12 @@ "tsequence_set_bbox", "tsequenceset_expand_bbox", "tsequenceset_set_bbox", - "tdiscseq_restrict_minmax", + "tcontseq_after_timestamptz", + "tcontseq_before_timestamptz", "tcontseq_restrict_minmax", + "tdiscseq_after_timestamptz", + "tdiscseq_before_timestamptz", + "tdiscseq_restrict_minmax", "temporal_bbox_restrict_set", "temporal_restrict_minmax", "temporal_restrict_timestamptz", @@ -2083,6 +2126,8 @@ "temporal_restrict_value", "temporal_restrict_values", "temporal_value_at_timestamptz", + "tinstant_after_timestamptz", + "tinstant_before_timestamptz", "tinstant_restrict_tstzspan", "tinstant_restrict_tstzspanset", "tinstant_restrict_timestamptz", @@ -2098,6 +2143,8 @@ "tsequence_at_timestamptz", "tsequence_restrict_tstzspan", "tsequence_restrict_tstzspanset", + "tsequenceset_after_timestamptz", + "tsequenceset_before_timestamptz", "tsequenceset_restrict_minmax", "tsequenceset_restrict_tstzspan", "tsequenceset_restrict_tstzspanset", @@ -2154,7 +2201,13 @@ "temporal_compact", "tsequence_compact", "tsequenceset_compact", + "temporal_skiplist_make", + "skiplist_search", "skiplist_free", + "skiplist_splice", + "temporal_skiplist_splice", + "skiplist_values", + "skiplist_keys_values", "temporal_app_tinst_transfn", "temporal_app_tseq_transfn", "span_bins", diff --git a/pymeos_cffi/functions.py b/pymeos_cffi/functions.py index b5d46eb..a64c92f 100644 --- a/pymeos_cffi/functions.py +++ b/pymeos_cffi/functions.py @@ -224,6 +224,77 @@ def timestamptz_out(t: int) -> Annotated[str, "char *"]: return result if result != _ffi.NULL else None +def rtree_create_intspan() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_intspan() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_bigintspan() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_bigintspan() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_floatspan() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_floatspan() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_datespan() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_datespan() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_tstzspan() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_tstzspan() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_tbox() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_tbox() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_create_stbox() -> Annotated[_ffi.CData, "RTree *"]: + result = _lib.rtree_create_stbox() + _check_error() + return result if result != _ffi.NULL else None + + +def rtree_free(rtree: Annotated[_ffi.CData, "RTree *"]) -> Annotated[None, "void"]: + rtree_converted = _ffi.cast("RTree *", rtree) + _lib.rtree_free(rtree_converted) + _check_error() + + +def rtree_insert( + rtree: Annotated[_ffi.CData, "RTree *"], box: Annotated[_ffi.CData, "void *"], id: int +) -> Annotated[None, "void"]: + rtree_converted = _ffi.cast("RTree *", rtree) + box_converted = _ffi.cast("void *", box) + id_converted = _ffi.cast("int64", id) + _lib.rtree_insert(rtree_converted, box_converted, id_converted) + _check_error() + + +def rtree_search( + rtree: Annotated[_ffi.CData, "const RTree *"], + query: Annotated[_ffi.CData, "const void *"], + count: Annotated[_ffi.CData, "int *"], +) -> Annotated[_ffi.CData, "int *"]: + rtree_converted = _ffi.cast("const RTree *", rtree) + query_converted = _ffi.cast("const void *", query) + count_converted = _ffi.cast("int *", count) + result = _lib.rtree_search(rtree_converted, query_converted, count_converted) + _check_error() + return result if result != _ffi.NULL else None + + def meos_errno() -> Annotated[int, "int"]: result = _lib.meos_errno() _check_error() @@ -400,12 +471,35 @@ def float_log10(d: float) -> Annotated[float, "double"]: return result if result != _ffi.NULL else None +def float8_out(d: float, maxdd: int) -> Annotated[str, "char *"]: + result = _lib.float8_out(d, maxdd) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + def float_round(d: float, maxdd: int) -> Annotated[float, "double"]: result = _lib.float_round(d, maxdd) _check_error() return result if result != _ffi.NULL else None +def int32_cmp(l: int, r: int) -> Annotated[int, "int"]: + l_converted = _ffi.cast("int32", l) + r_converted = _ffi.cast("int32", r) + result = _lib.int32_cmp(l_converted, r_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def int64_cmp(l: int, r: int) -> Annotated[int, "int"]: + l_converted = _ffi.cast("int64", l) + r_converted = _ffi.cast("int64", r) + result = _lib.int64_cmp(l_converted, r_converted) + _check_error() + return result if result != _ffi.NULL else None + + def interval_make( years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float ) -> Annotated[_ffi.CData, "Interval *"]: @@ -422,7 +516,7 @@ def interval_make( return result if result != _ffi.NULL else None -def minus_date_date(d1: int, d2: int) -> Annotated[_ffi.CData, "Interval *"]: +def minus_date_date(d1: int, d2: int) -> Annotated[int, "int"]: d1_converted = _ffi.cast("DateADT", d1) d2_converted = _ffi.cast("DateADT", d2) result = _lib.minus_date_date(d1_converted, d2_converted) @@ -560,6 +654,14 @@ def text_copy(txt: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None +def text_in(string: str) -> Annotated[str, "text *"]: + string_converted = string.encode("utf-8") + result = _lib.text_in(string_converted) + _check_error() + result = text2cstring(result) + return result if result != _ffi.NULL else None + + def text_initcap(txt: str) -> Annotated[str, "text *"]: txt_converted = cstring2text(txt) result = _lib.text_initcap(txt_converted) @@ -638,6 +740,14 @@ def bigintset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, " return result if result != _ffi.NULL else None +def bigintspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("int64", value) + result = _lib.bigintspan_expand(s_converted, value_converted) + _check_error() + return result if result != _ffi.NULL else None + + def bigintspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: string_converted = string.encode("utf-8") result = _lib.bigintspan_in(string_converted) @@ -728,6 +838,13 @@ def floatset_out(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annot return result if result != _ffi.NULL else None +def floatspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: float) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_expand(s_converted, value) + _check_error() + return result if result != _ffi.NULL else None + + def floatspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: string_converted = string.encode("utf-8") result = _lib.floatspan_in(string_converted) @@ -773,6 +890,14 @@ def intset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "cha return result if result != _ffi.NULL else None +def intspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("int32", value) + result = _lib.intspan_expand(s_converted, value_converted) + _check_error() + return result if result != _ffi.NULL else None + + def intspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: string_converted = string.encode("utf-8") result = _lib.intspan_in(string_converted) @@ -2089,16 +2214,6 @@ def intspanset_shift_scale( return result if result != _ffi.NULL else None -def numspan_expand( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) - result = _lib.numspan_expand(s_converted, value_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tstzspan_expand( s: Annotated[_ffi.CData, "const Span *"], interv: Annotated[_ffi.CData, "const Interval *"] ) -> Annotated[_ffi.CData, "Span *"]: @@ -5824,6 +5939,21 @@ def timestamptz_to_tbox(t: int) -> Annotated[_ffi.CData, "TBox *"]: return result if result != _ffi.NULL else None +def tbox_hash(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[int, "uint32"]: + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_hash(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_hash_extended(box: Annotated[_ffi.CData, "const TBox *"], seed: int) -> Annotated[int, "uint64"]: + box_converted = _ffi.cast("const TBox *", box) + seed_converted = _ffi.cast("uint64", seed) + result = _lib.tbox_hash_extended(box_converted, seed_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tbox_hast(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[bool, "bool"]: box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_hast(box_converted) @@ -5958,64 +6088,64 @@ def tboxint_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.C return None -def tbox_expand_float(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: +def tbox_expand_time( + box: Annotated[_ffi.CData, "const TBox *"], interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_expand_float(box_converted, d) + 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_int(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: +def tbox_round(box: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_expand_int(box_converted, i) + result = _lib.tbox_round(box_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_time( - box: Annotated[_ffi.CData, "const TBox *"], interv: Annotated[_ffi.CData, "const Interval *"] +def tbox_shift_scale_time( + box: Annotated[_ffi.CData, "const TBox *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, ) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - interv_converted = _ffi.cast("const Interval *", interv) - result = _lib.tbox_expand_time(box_converted, interv_converted) + 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 tbox_round(box: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[_ffi.CData, "TBox *"]: +def tfloatbox_expand(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_round(box_converted, maxdd) + result = _lib.tfloatbox_expand(box_converted, d) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_float( +def tfloatbox_shift_scale( box: Annotated[_ffi.CData, "const TBox *"], shift: float, width: float, hasshift: bool, haswidth: bool ) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_shift_scale_float(box_converted, shift, width, hasshift, haswidth) + result = _lib.tfloatbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_int( - box: Annotated[_ffi.CData, "const TBox *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "TBox *"]: +def tintbox_expand(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_shift_scale_int(box_converted, shift, width, hasshift, haswidth) + result = _lib.tintbox_expand(box_converted, i) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_time( - box: Annotated[_ffi.CData, "const TBox *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, +def tintbox_shift_scale( + box: Annotated[_ffi.CData, "const TBox *"], shift: int, width: int, hasshift: bool, haswidth: bool ) -> Annotated[_ffi.CData, "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) + result = _lib.tintbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None @@ -6509,35 +6639,35 @@ def tintseqset_from_base_tstzspanset( def tsequence_make( - instants: Annotated[list, "const TInstant **"], + instants: Annotated[list, "TInstant **"], count: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool, ) -> Annotated[_ffi.CData, "TSequence *"]: - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tsequence_make(instants_converted, count, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None def tsequenceset_make( - sequences: Annotated[list, "const TSequence **"], count: int, normalize: bool + sequences: Annotated[list, "TSequence **"], count: int, normalize: bool ) -> Annotated[_ffi.CData, "TSequenceSet *"]: - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] + sequences_converted = [_ffi.cast("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: Annotated[list, "const TInstant **"], + instants: Annotated[list, "TInstant **"], interp: InterpolationType, maxt: Annotated[_ffi.CData, "const Interval *"] | None, maxdist: float, ) -> Annotated[_ffi.CData, "TSequenceSet *"]: - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] maxt_converted = _ffi.cast("const Interval *", maxt) if maxt is not None else _ffi.NULL result = _lib.tsequenceset_make_gaps(instants_converted, len(instants), interp, maxt_converted, maxdist) _check_error() @@ -6785,6 +6915,19 @@ def temporal_num_timestamps(temp: Annotated[_ffi.CData, "const Temporal *"]) -> return result if result != _ffi.NULL else None +def temporal_segm_duration( + temp: Annotated[_ffi.CData, "const Temporal *"], + duration: Annotated[_ffi.CData, "const Interval *"], + atleast: bool, + strict: bool, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + result = _lib.temporal_segm_duration(temp_converted, duration_converted, atleast, strict) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_segments( temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] ) -> Annotated[_ffi.CData, "TSequence **"]: @@ -6896,16 +7039,16 @@ def tfloat_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotat return result if result != _ffi.NULL else None -def tfloat_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: +def tfloat_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tfloat_max_value(temp_converted) + result = _lib.tfloat_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: +def tfloat_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tfloat_min_value(temp_converted) + result = _lib.tfloat_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None @@ -7011,6 +7154,13 @@ def tint_values( return result if result != _ffi.NULL else None +def tnumber_avg_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_avg_value(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tnumber_integral(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnumber_integral(temp_converted) @@ -7103,10 +7253,8 @@ def float_degrees(value: float, normalize: bool) -> Annotated[float, "double"]: return result if result != _ffi.NULL else None -def temparr_round( - temp: Annotated[list, "const Temporal **"], count: int, maxdd: int -) -> Annotated[_ffi.CData, "Temporal **"]: - temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] +def temparr_round(temp: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "Temporal **"]: + temp_converted = [_ffi.cast("Temporal *", x) for x in temp] result = _lib.temparr_round(temp_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None @@ -7356,10 +7504,8 @@ def temporal_merge( return result if result != _ffi.NULL else None -def temporal_merge_array( - temparr: Annotated[list, "const Temporal **"], count: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] +def temporal_merge_array(temparr: Annotated[list, "Temporal **"], count: int) -> Annotated[_ffi.CData, "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 @@ -7389,6 +7535,16 @@ def tbool_minus_value(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) return result if result != _ffi.NULL else None +def temporal_after_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.temporal_after_timestamptz(temp_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_at_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_at_max(temp_converted) @@ -7453,6 +7609,16 @@ def temporal_at_values( return result if result != _ffi.NULL else None +def temporal_before_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.temporal_before_timestamptz(temp_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_minus_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_minus_max(temp_converted) @@ -9914,6 +10080,13 @@ def tnumber_abs(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_f return result if result != _ffi.NULL else None +def tnumber_trend(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_trend(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + def float_angular_difference(degrees1: float, degrees2: float) -> Annotated[float, "double"]: result = _lib.float_angular_difference(degrees1, degrees2) _check_error() @@ -11330,13 +11503,6 @@ def geo_out(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[str, return result if result != _ffi.NULL else None -def geog_from_binary(wkb_bytea: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - wkb_bytea_converted = wkb_bytea.encode("utf-8") - result = _lib.geog_from_binary(wkb_bytea_converted) - _check_error() - return result if result != _ffi.NULL else None - - def geog_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: wkt_converted = wkt.encode("utf-8") result = _lib.geog_from_hexewkb(wkt_converted) @@ -11367,6 +11533,39 @@ def geom_in(string: str, typmod: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: return result if result != _ffi.NULL else None +def box3d_make( + xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "BOX3D *"]: + srid_converted = _ffi.cast("int32_t", srid) + result = _lib.box3d_make(xmin, xmax, ymin, ymax, zmin, zmax, srid_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def box3d_out(box: Annotated[_ffi.CData, "const BOX3D *"], maxdd: int) -> Annotated[str, "char *"]: + box_converted = _ffi.cast("const BOX3D *", box) + result = _lib.box3d_out(box_converted, maxdd) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def gbox_make( + hasz: bool, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float +) -> Annotated[_ffi.CData, "GBOX *"]: + result = _lib.gbox_make(hasz, xmin, xmax, ymin, ymax, zmin, zmax) + _check_error() + return result if result != _ffi.NULL else None + + +def gbox_out(box: Annotated[_ffi.CData, "const GBOX *"], maxdd: int) -> Annotated[str, "char *"]: + box_converted = _ffi.cast("const GBOX *", box) + result = _lib.gbox_out(box_converted, maxdd) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + def geo_copy(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geo_copy(g_converted) @@ -11431,6 +11630,13 @@ def geo_is_empty(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[b return result if result != _ffi.NULL else None +def geo_is_unitary(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[bool, "bool"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_is_unitary(gs_converted) + _check_error() + return result if result != _ffi.NULL else None + + def geo_typename(type: int) -> Annotated[str, "const char *"]: result = _lib.geo_typename(type) _check_error() @@ -11541,9 +11747,9 @@ def geo_srid(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi def geo_transform( - geom: Annotated[_ffi.CData, "GSERIALIZED *"], srid_to: Annotated[_ffi.CData, "int32_t"] + geom: Annotated[_ffi.CData, "const GSERIALIZED *"], srid_to: Annotated[_ffi.CData, "int32_t"] ) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("GSERIALIZED *", geom) + geom_converted = _ffi.cast("const GSERIALIZED *", geom) srid_to_converted = _ffi.cast("int32_t", srid_to) result = _lib.geo_transform(geom_converted, srid_to_converted) _check_error() @@ -11578,23 +11784,40 @@ def geo_makeline_garray(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> return result if result != _ffi.NULL else None -def geo_npoints(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: +def geo_num_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: gs_converted = _ffi.cast("const GSERIALIZED *", gs) - result = _lib.geo_npoints(gs_converted) + result = _lib.geo_num_points(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_ngeos(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: +def geo_num_geos(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: gs_converted = _ffi.cast("const GSERIALIZED *", gs) - result = _lib.geo_ngeos(gs_converted) + result = _lib.geo_num_geos(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_geoN(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: +def geo_geo_n(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: geom_converted = _ffi.cast("const GSERIALIZED *", geom) - result = _lib.geo_geoN(geom_converted, n) + result = _lib.geo_geo_n(geom_converted, n) + _check_error() + return result if result != _ffi.NULL else None + + +def geo_pointarr( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], count: Annotated[_ffi.CData, "int *"] +) -> Annotated[_ffi.CData, "GSERIALIZED **"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + count_converted = _ffi.cast("int *", count) + result = _lib.geo_pointarr(gs_converted, count_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def geo_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_points(gs_converted) _check_error() return result if result != _ffi.NULL else None @@ -11657,6 +11880,26 @@ def geom_intersection2d( return result if result != _ffi.NULL else None +def geom_intersection2d_coll( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) + result = _lib.geom_intersection2d_coll(gs1_converted, gs2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def geom_min_bounding_radius( + geom: Annotated[_ffi.CData, "const GSERIALIZED *"], radius: Annotated[_ffi.CData, "double *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) + radius_converted = _ffi.cast("double *", radius) + result = _lib.geom_min_bounding_radius(geom_converted, radius_converted) + _check_error() + return result if result != _ffi.NULL else None + + def geom_shortestline2d( gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], s2: Annotated[_ffi.CData, "const GSERIALIZED *"] ) -> Annotated[_ffi.CData, "GSERIALIZED *"]: @@ -11677,17 +11920,19 @@ def geom_shortestline3d( return result if result != _ffi.NULL else None -def geom_unary_union(gs: Annotated[_ffi.CData, "GSERIALIZED *"], prec: float) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def geom_unary_union( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], prec: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_unary_union(gs_converted, prec) _check_error() return result if result != _ffi.NULL else None def line_interpolate_point( - gs: Annotated[_ffi.CData, "GSERIALIZED *"], distance_fraction: float, repeat: bool + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], distance_fraction: float, repeat: bool ) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("GSERIALIZED *", gs) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.line_interpolate_point(gs_converted, distance_fraction, repeat) _check_error() return result if result != _ffi.NULL else None @@ -11942,8 +12187,8 @@ def spatialset_as_ewkt(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> return result if result != _ffi.NULL else None -def geoset_make(values: Annotated[list, "const GSERIALIZED **"]) -> Annotated[_ffi.CData, "Set *"]: - values_converted = [_ffi.cast("const GSERIALIZED *", x) for x in values] +def geoset_make(values: Annotated[list, "GSERIALIZED **"]) -> Annotated[_ffi.CData, "Set *"]: + values_converted = [_ffi.cast("GSERIALIZED *", x) for x in values] result = _lib.geoset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None @@ -12291,6 +12536,21 @@ def stbox_area(box: Annotated[_ffi.CData, "const STBox *"], spheroid: bool) -> A return result if result != _ffi.NULL else None +def stbox_hash(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[int, "uint32"]: + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_hash(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_hash_extended(box: Annotated[_ffi.CData, "const STBox *"], seed: int) -> Annotated[int, "uint64"]: + box_converted = _ffi.cast("const STBox *", box) + seed_converted = _ffi.cast("uint64", seed) + result = _lib.stbox_hash_extended(box_converted, seed_converted) + _check_error() + return result if result != _ffi.NULL else None + + def stbox_hast(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "bool"]: box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_hast(box_converted) @@ -12837,49 +13097,6 @@ def stbox_ne( return result if result != _ffi.NULL else None -def rtree_create_stbox() -> Annotated[_ffi.CData, "RTree *"]: - result = _lib.rtree_create_stbox() - _check_error() - return result if result != _ffi.NULL else None - - -def rtree_free(rtree: Annotated[_ffi.CData, "RTree *"]) -> Annotated[None, "void"]: - rtree_converted = _ffi.cast("RTree *", rtree) - _lib.rtree_free(rtree_converted) - _check_error() - - -def rtree_insert( - rtree: Annotated[_ffi.CData, "RTree *"], box: Annotated[_ffi.CData, "STBox *"], id: int -) -> Annotated[None, "void"]: - rtree_converted = _ffi.cast("RTree *", rtree) - box_converted = _ffi.cast("STBox *", box) - id_converted = _ffi.cast("int64", id) - _lib.rtree_insert(rtree_converted, box_converted, id_converted) - _check_error() - - -def rtree_search( - rtree: Annotated[_ffi.CData, "const RTree *"], - query: Annotated[_ffi.CData, "const STBox *"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "int *"]: - rtree_converted = _ffi.cast("const RTree *", rtree) - query_converted = _ffi.cast("const STBox *", query) - count_converted = _ffi.cast("int *", count) - result = _lib.rtree_search(rtree_converted, query_converted, count_converted) - _check_error() - return result if result != _ffi.NULL else None - - -def tgeo_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tgeo_out(temp_converted, maxdd) - _check_error() - result = _ffi.string(result).decode("utf-8") - return result if result != _ffi.NULL else None - - def tgeogpoint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: string_converted = string.encode("utf-8") result = _lib.tgeogpoint_from_mfjson(string_converted) @@ -12952,6 +13169,14 @@ def tspatial_as_text(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int return result if result != _ffi.NULL else None +def tspatial_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tspatial_out(temp_converted, maxdd) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + def tgeo_from_base_temp( gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] ) -> Annotated[_ffi.CData, "Temporal *"]: @@ -15287,10 +15512,12 @@ def geo_cluster_dbscan( ngeoms: Annotated[_ffi.CData, "uint32_t"], tolerance: float, minpoints: int, + count: Annotated[_ffi.CData, "int *"], ) -> Annotated[_ffi.CData, "uint32_t *"]: geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] ngeoms_converted = _ffi.cast("uint32_t", ngeoms) - result = _lib.geo_cluster_dbscan(geoms_converted, ngeoms_converted, tolerance, minpoints) + count_converted = _ffi.cast("int *", count) + result = _lib.geo_cluster_dbscan(geoms_converted, ngeoms_converted, tolerance, minpoints, count_converted) _check_error() return result if result != _ffi.NULL else None @@ -15742,6 +15969,16 @@ def numset_shift_scale( return result if result != _ffi.NULL else None +def numspan_expand( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.numspan_expand(s_converted, value_converted) + _check_error() + return result if result != _ffi.NULL else None + + def numspan_shift_scale( s: Annotated[_ffi.CData, "const Span *"], shift: Annotated[_ffi.CData, "Datum"], @@ -15808,12 +16045,12 @@ def tbox_expand_value( return result if result != _ffi.NULL else None -def textcat_textset_text_int( +def textcat_textset_text_common( s: Annotated[_ffi.CData, "const Set *"], txt: str, invert: bool ) -> Annotated[_ffi.CData, "Set *"]: s_converted = _ffi.cast("const Set *", s) txt_converted = cstring2text(txt) - result = _lib.textcat_textset_text_int(s_converted, txt_converted, invert) + result = _lib.textcat_textset_text_common(s_converted, txt_converted, invert) _check_error() return result if result != _ffi.NULL else None @@ -16177,6 +16414,53 @@ def right_spanset_value( return result if result != _ffi.NULL else None +def bbox_type(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) + result = _lib.bbox_type(bboxtype_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def bbox_get_size(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "size_t"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) + result = _lib.bbox_get_size(bboxtype_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def bbox_max_dims(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[int, "int"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) + result = _lib.bbox_max_dims(bboxtype_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_bbox_eq( + box1: Annotated[_ffi.CData, "const void *"], + box2: Annotated[_ffi.CData, "const void *"], + temptype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[bool, "bool"]: + box1_converted = _ffi.cast("const void *", box1) + box2_converted = _ffi.cast("const void *", box2) + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.temporal_bbox_eq(box1_converted, box2_converted, temptype_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_bbox_cmp( + box1: Annotated[_ffi.CData, "const void *"], + box2: Annotated[_ffi.CData, "const void *"], + temptype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[int, "int"]: + box1_converted = _ffi.cast("const void *", box1) + box2_converted = _ffi.cast("const void *", box2) + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.temporal_bbox_cmp(box1_converted, box2_converted, temptype_converted) + _check_error() + return result if result != _ffi.NULL else None + + def bbox_union_span_span( s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] ) -> Annotated[_ffi.CData, "Span *"]: @@ -16694,10 +16978,8 @@ def temporal_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> return result if result != _ffi.NULL else None -def temparr_out( - temparr: Annotated[list, "const Temporal **"], count: int, maxdd: int -) -> Annotated[_ffi.CData, "char **"]: - temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] +def temparr_out(temparr: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "char **"]: + temparr_converted = [_ffi.cast("Temporal *", x) for x in temparr] result = _lib.temparr_out(temparr_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None @@ -16918,7 +17200,7 @@ def tsequence_from_base_tstzspan( def tsequence_make_exp( - instants: Annotated[list, "const TInstant **"], + instants: Annotated[list, "TInstant **"], count: int, maxcount: int, lower_inc: bool, @@ -16926,7 +17208,7 @@ def tsequence_make_exp( interp: InterpolationType, normalize: bool, ) -> Annotated[_ffi.CData, "TSequence *"]: - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tsequence_make_exp(instants_converted, count, maxcount, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None @@ -16990,9 +17272,9 @@ def tsequenceset_from_base_tstzspanset( def tsequenceset_make_exp( - sequences: Annotated[list, "const TSequence **"], count: int, maxcount: int, normalize: bool + sequences: Annotated[list, "TSequence **"], count: int, maxcount: int, normalize: bool ) -> Annotated[_ffi.CData, "TSequenceSet *"]: - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] + sequences_converted = [_ffi.cast("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 @@ -17102,12 +17384,19 @@ def temporal_inst_n( return result if result != _ffi.NULL else None -def temporal_instants_p( +def temporal_insts_p( temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] ) -> Annotated[_ffi.CData, "const TInstant **"]: temp_converted = _ffi.cast("const Temporal *", temp) count_converted = _ffi.cast("int *", count) - result = _lib.temporal_instants_p(temp_converted, count_converted) + result = _lib.temporal_insts_p(temp_converted, count_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_max_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_max_inst_p(temp_converted) _check_error() return result if result != _ffi.NULL else None @@ -17126,6 +17415,13 @@ def temporal_mem_size(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annota return result if result != _ffi.NULL else None +def temporal_min_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_min_inst_p(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Datum"]: temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_min_value(temp_converted) @@ -17292,6 +17588,13 @@ def tnumberinst_valuespans(inst: Annotated[_ffi.CData, "const TInstant *"]) -> A return result if result != _ffi.NULL else None +def tnumberseq_avg_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_avg_val(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tnumberseq_valuespans(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "SpanSet *"]: seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tnumberseq_valuespans(seq_converted) @@ -17299,6 +17602,13 @@ def tnumberseq_valuespans(seq: Annotated[_ffi.CData, "const TSequence *"]) -> An return result if result != _ffi.NULL else None +def tnumberseqset_avg_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_avg_val(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tnumberseqset_valuespans(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tnumberseqset_valuespans(ss_converted) @@ -17334,9 +17644,9 @@ def tsequence_insts_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annota return result if result != _ffi.NULL else None -def tsequence_max_inst(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: +def tsequence_max_inst_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: seq_converted = _ffi.cast("const TSequence *", seq) - result = _lib.tsequence_max_inst(seq_converted) + result = _lib.tsequence_max_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None @@ -17348,9 +17658,9 @@ def tsequence_max_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annota return result if result != _ffi.NULL else None -def tsequence_min_inst(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: +def tsequence_min_inst_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: seq_converted = _ffi.cast("const TSequence *", seq) - result = _lib.tsequence_min_inst(seq_converted) + result = _lib.tsequence_min_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None @@ -17470,11 +17780,11 @@ def tsequenceset_insts_p( return result if result != _ffi.NULL else None -def tsequenceset_max_inst( +def tsequenceset_max_inst_p( ss: Annotated[_ffi.CData, "const TSequenceSet *"], ) -> Annotated[_ffi.CData, "const TInstant *"]: ss_converted = _ffi.cast("const TSequenceSet *", ss) - result = _lib.tsequenceset_max_inst(ss_converted) + result = _lib.tsequenceset_max_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None @@ -17486,11 +17796,11 @@ def tsequenceset_max_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> A return result if result != _ffi.NULL else None -def tsequenceset_min_inst( +def tsequenceset_min_inst_p( ss: Annotated[_ffi.CData, "const TSequenceSet *"], ) -> Annotated[_ffi.CData, "const TInstant *"]: ss_converted = _ffi.cast("const TSequenceSet *", ss) - result = _lib.tsequenceset_min_inst(ss_converted) + result = _lib.tsequenceset_min_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None @@ -17866,10 +18176,8 @@ def tinstant_merge( return result if result != _ffi.NULL else None -def tinstant_merge_array( - instants: Annotated[list, "const TInstant **"], count: int -) -> Annotated[_ffi.CData, "Temporal *"]: - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] +def tinstant_merge_array(instants: Annotated[list, "TInstant **"], count: int) -> Annotated[_ffi.CData, "Temporal *"]: + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tinstant_merge_array(instants_converted, count) _check_error() return result if result != _ffi.NULL else None @@ -17961,9 +18269,9 @@ def tsequence_merge( def tsequence_merge_array( - sequences: Annotated[list, "const TSequence **"], count: int + sequences: Annotated[list, "TSequence **"], count: int ) -> Annotated[_ffi.CData, "Temporal *"]: - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] + sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] result = _lib.tsequence_merge_array(sequences_converted, count) _check_error() return result if result != _ffi.NULL else None @@ -18055,9 +18363,9 @@ def tsequenceset_merge( def tsequenceset_merge_array( - seqsets: Annotated[list, "const TSequenceSet **"], count: int + seqsets: Annotated[list, "TSequenceSet **"], count: int ) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seqsets_converted = [_ffi.cast("const TSequenceSet *", x) for x in seqsets] + seqsets_converted = [_ffi.cast("TSequenceSet *", x) for x in seqsets] result = _lib.tsequenceset_merge_array(seqsets_converted, count) _check_error() return result if result != _ffi.NULL else None @@ -18099,11 +18407,22 @@ def tsequenceset_set_bbox( _check_error() -def tdiscseq_restrict_minmax( - seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool +def tcontseq_after_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool ) -> Annotated[_ffi.CData, "TSequence *"]: seq_converted = _ffi.cast("const TSequence *", seq) - result = _lib.tdiscseq_restrict_minmax(seq_converted, min, atfunc) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tcontseq_after_timestamptz(seq_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + +def tcontseq_before_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tcontseq_before_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None @@ -18117,6 +18436,35 @@ def tcontseq_restrict_minmax( return result if result != _ffi.NULL else None +def tdiscseq_after_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tdiscseq_after_timestamptz(seq_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + +def tdiscseq_before_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tdiscseq_before_timestamptz(seq_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + +def tdiscseq_restrict_minmax( + seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool +) -> Annotated[_ffi.CData, "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 temporal_bbox_restrict_set( temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] ) -> Annotated[bool, "bool"]: @@ -18209,6 +18557,26 @@ def temporal_value_at_timestamptz( return None +def tinstant_after_timestamptz( + inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tinstant_after_timestamptz(inst_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_before_timestamptz( + inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tinstant_before_timestamptz(inst_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + def tinstant_restrict_tstzspan( inst: Annotated[_ffi.CData, "const TInstant *"], period: Annotated[_ffi.CData, "const Span *"], atfunc: bool ) -> Annotated[_ffi.CData, "TInstant *"]: @@ -18359,6 +18727,26 @@ def tsequence_restrict_tstzspanset( return result if result != _ffi.NULL else None +def tsequenceset_after_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequenceset_after_timestamptz(ss_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_before_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequenceset_before_timestamptz(ss_converted, t_converted, strict) + _check_error() + return result if result != _ffi.NULL else None + + def tsequenceset_restrict_minmax( ss: Annotated[_ffi.CData, "const TSequenceSet *"], min: bool, atfunc: bool ) -> Annotated[_ffi.CData, "TSequenceSet *"]: @@ -18882,12 +19270,82 @@ def tsequenceset_compact(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> A return result if result != _ffi.NULL else None +def temporal_skiplist_make() -> Annotated[_ffi.CData, "SkipList *"]: + result = _lib.temporal_skiplist_make() + _check_error() + return result if result != _ffi.NULL else None + + +def skiplist_search( + list: Annotated[_ffi.CData, "SkipList *"], + key: Annotated[_ffi.CData, "void *"], + value: Annotated[_ffi.CData, "void *"], +) -> Annotated[int, "int"]: + list_converted = _ffi.cast("SkipList *", list) + key_converted = _ffi.cast("void *", key) + value_converted = _ffi.cast("void *", value) + result = _lib.skiplist_search(list_converted, key_converted, value_converted) + _check_error() + return result if result != _ffi.NULL else None + + def skiplist_free(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[None, "void"]: list_converted = _ffi.cast("SkipList *", list) _lib.skiplist_free(list_converted) _check_error() +def skiplist_splice( + list: Annotated[_ffi.CData, "SkipList *"], + keys: Annotated[list, "void **"], + values: Annotated[list, "void **"], + count: int, + func: Annotated[_ffi.CData, "datum_func2"], + crossings: bool, + sktype: Annotated[_ffi.CData, "SkipListType"], +) -> Annotated[None, "void"]: + list_converted = _ffi.cast("SkipList *", list) + keys_converted = [_ffi.cast("void *", x) for x in keys] + values_converted = [_ffi.cast("void *", x) for x in values] + func_converted = _ffi.cast("datum_func2", func) + sktype_converted = _ffi.cast("SkipListType", sktype) + _lib.skiplist_splice( + list_converted, keys_converted, values_converted, count, func_converted, crossings, sktype_converted + ) + _check_error() + + +def temporal_skiplist_splice( + list: Annotated[_ffi.CData, "SkipList *"], + values: Annotated[list, "void **"], + count: int, + func: Annotated[_ffi.CData, "datum_func2"], + crossings: bool, +) -> Annotated[None, "void"]: + list_converted = _ffi.cast("SkipList *", list) + values_converted = [_ffi.cast("void *", x) for x in values] + func_converted = _ffi.cast("datum_func2", func) + _lib.temporal_skiplist_splice(list_converted, values_converted, count, func_converted, crossings) + _check_error() + + +def skiplist_values(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "void **"]: + list_converted = _ffi.cast("SkipList *", list) + result = _lib.skiplist_values(list_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def skiplist_keys_values( + list: Annotated[_ffi.CData, "SkipList *"], values: Annotated[list, "void **"] +) -> Annotated[_ffi.CData, "void **"]: + list_converted = _ffi.cast("SkipList *", list) + values_converted = [_ffi.cast("void *", x) for x in values] + result = _lib.skiplist_keys_values(list_converted, values_converted) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_app_tinst_transfn( state: Annotated[_ffi.CData, "Temporal *"], inst: Annotated[_ffi.CData, "const TInstant *"], @@ -19918,7 +20376,7 @@ def route_exists(rid: int) -> Annotated[bool, "bool"]: return result if result != _ffi.NULL else None -def route_geom(rid: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: +def route_geom(rid: int) -> Annotated[_ffi.CData, "const GSERIALIZED *"]: rid_converted = _ffi.cast("int64", rid) result = _lib.route_geom(rid_converted) _check_error() @@ -20151,8 +20609,8 @@ def npointset_out(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annota return result if result != _ffi.NULL else None -def npointset_make(values: Annotated[list, "const Npoint **"], count: int) -> Annotated[_ffi.CData, "Set *"]: - values_converted = [_ffi.cast("const Npoint *", x) for x in values] +def npointset_make(values: Annotated[list, "Npoint **"], count: int) -> Annotated[_ffi.CData, "Set *"]: + values_converted = [_ffi.cast("Npoint *", x) for x in values] result = _lib.npointset_make(values_converted, count) _check_error() return result if result != _ffi.NULL else None @@ -20214,10 +20672,10 @@ def contained_npoint_set( def contains_set_npoint( - s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "Npoint *"] + s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] ) -> Annotated[bool, "bool"]: s_converted = _ffi.cast("const Set *", s) - np_converted = _ffi.cast("Npoint *", np) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.contains_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None From f42ecf1ad9fd6530e97adb83edc6b6cf2bd0a172 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:22:51 +0200 Subject: [PATCH 02/11] ci: add PR build validation workflow The existing build_pymeos_cffi.yml only triggers on tag pushes (releases). Bumping the vendored meos.h and regenerating the codegen output needs end-to-end build validation before tagging, or regressions like signature mismatches reach a release. PR build workflow derives the target MEOS branch from __version__ in pymeos_cffi/__init__.py (e.g. 1.3.0a2 -> stable-1.3, falling back to master if the stable-X.Y branch does not exist), clones+installs MEOS from that branch on Ubuntu, macOS-13 (x86) and macOS-14 (arm64), builds the sdist, installs it, and smoke- tests by initialising MEOS and asserting a representative function resolves. Cancellation concurrency keyed on the branch so a force-push abandons stale runs. --- .github/workflows/pr_build.yml | 107 +++++++++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 .github/workflows/pr_build.yml diff --git a/.github/workflows/pr_build.yml b/.github/workflows/pr_build.yml new file mode 100644 index 0000000..649881c --- /dev/null +++ b/.github/workflows/pr_build.yml @@ -0,0 +1,107 @@ +name: PR build validation + +on: + pull_request: + branches: [master, "stable-[0-9]+.[0-9]+"] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + name: Build PyMEOS CFFI on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-13, macos-14] + include: + - ld_prefix: "/usr/local" + - os: macos-14 + ld_prefix: "/opt/homebrew" + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Derive MEOS branch from package version + id: meos_branch + shell: bash + run: | + python_version=$(grep -oP '__version__ = "\K[^"]+' pymeos_cffi/__init__.py) + major_minor=$(echo "$python_version" | grep -oE '^[0-9]+\.[0-9]+') + candidate="stable-${major_minor}" + if git ls-remote --exit-code https://github.com/MobilityDB/MobilityDB "$candidate" >/dev/null 2>&1; then + meos_branch=$candidate + else + meos_branch="master" + fi + echo "Package version $python_version => MEOS branch $meos_branch" + echo "meos_branch=$meos_branch" >> "$GITHUB_OUTPUT" + + - name: Install MEOS build deps (Linux) + if: runner.os == 'Linux' + run: | + sudo apt-get update + sudo apt-get install -y build-essential cmake postgresql-server-dev-all \ + libproj-dev libgeos-dev libgsl-dev libjson-c-dev + + - name: Install MEOS build deps (macOS) + if: runner.os == 'macOS' + uses: tecolicom/actions-use-homebrew-tools@v1 + with: + tools: cmake libpq proj json-c gsl geos + + - name: Build and install MEOS + shell: bash + run: | + git clone --depth 1 --branch ${{ steps.meos_branch.outputs.meos_branch }} \ + https://github.com/MobilityDB/MobilityDB + mkdir MobilityDB/build + cd MobilityDB/build + if [ "${{ runner.os }}" = "macOS" ]; then + export MACOSX_DEPLOYMENT_TARGET="${{ matrix.os == 'macos-14' && 14 || 13.6 }}" + fi + cmake .. -DMEOS=ON -DCMAKE_BUILD_TYPE=Release + make -j + sudo make install + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + cache: "pip" + + - name: Install build dependencies + run: | + python -m pip install --upgrade pip + python -m pip install build cffi setuptools + + - name: Build sdist + run: | + python -m build -s + ls -l dist + + - name: Install from sdist + shell: bash + run: | + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${{ matrix.ld_prefix }}/lib + export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:${{ matrix.ld_prefix }}/lib + pip install dist/pymeos_cffi-*.tar.gz + + - name: Smoke-test CFFI binding + shell: bash + run: | + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${{ matrix.ld_prefix }}/lib + export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:${{ matrix.ld_prefix }}/lib + python -c " + import pymeos_cffi + from pymeos_cffi import meos_initialize, meos_finalize + meos_initialize('UTC') + # Confirm a representative C function resolves + assert callable(pymeos_cffi.tstzspan_make), 'tstzspan_make missing' + meos_finalize() + print('PyMEOS CFFI build + smoke test OK on ${{ matrix.os }}') + " From 6a3d78df5cb2fa29c6b22a3f49998c9cf8b26718 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:26:01 +0200 Subject: [PATCH 03/11] ci: reformat build_pymeos_functions_modifiers.py to satisfy ruff --- builder/build_pymeos_functions_modifiers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/builder/build_pymeos_functions_modifiers.py b/builder/build_pymeos_functions_modifiers.py index 9db92ba..bd1c14f 100644 --- a/builder/build_pymeos_functions_modifiers.py +++ b/builder/build_pymeos_functions_modifiers.py @@ -80,8 +80,8 @@ def text2cstring_modifier(_: str) -> str: def from_wkb_modifier(function: str, return_type: str) -> Callable[[str], str]: - return ( - lambda _: f"""def {function}(wkb: bytes) -> '{return_type} *': + return lambda _: ( + f"""def {function}(wkb: bytes) -> '{return_type} *': wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.{function}(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None""" From a0a414977b94d4839c196192a085e18147aa0e48 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:27:38 +0200 Subject: [PATCH 04/11] ci: pin postgresql-server-dev to 16 to avoid pgdg vs ubuntu repo conflict --- .github/workflows/pr_build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr_build.yml b/.github/workflows/pr_build.yml index 649881c..b8ef476 100644 --- a/.github/workflows/pr_build.yml +++ b/.github/workflows/pr_build.yml @@ -45,7 +45,7 @@ jobs: if: runner.os == 'Linux' run: | sudo apt-get update - sudo apt-get install -y build-essential cmake postgresql-server-dev-all \ + sudo apt-get install -y build-essential cmake postgresql-server-dev-16 \ libproj-dev libgeos-dev libgsl-dev libjson-c-dev - name: Install MEOS build deps (macOS) From 614d5de65e03ebfe4a4360bf8070c2529d1ee52d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:29:35 +0200 Subject: [PATCH 05/11] ci: use POSIX sed instead of grep -P for macOS portability --- .github/workflows/pr_build.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pr_build.yml b/.github/workflows/pr_build.yml index b8ef476..fb3498a 100644 --- a/.github/workflows/pr_build.yml +++ b/.github/workflows/pr_build.yml @@ -30,8 +30,8 @@ jobs: id: meos_branch shell: bash run: | - python_version=$(grep -oP '__version__ = "\K[^"]+' pymeos_cffi/__init__.py) - major_minor=$(echo "$python_version" | grep -oE '^[0-9]+\.[0-9]+') + python_version=$(sed -nE 's/^__version__ = "([^"]+)".*/\1/p' pymeos_cffi/__init__.py) + major_minor=$(echo "$python_version" | sed -nE 's/^([0-9]+\.[0-9]+).*/\1/p') candidate="stable-${major_minor}" if git ls-remote --exit-code https://github.com/MobilityDB/MobilityDB "$candidate" >/dev/null 2>&1; then meos_branch=$candidate From 760851ed4663b16d90bcfbea1bffd5c2adfd79db Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 10:32:34 +0200 Subject: [PATCH 06/11] ci: install MEOS to the matrix ld_prefix so dyld finds it on macos-14 --- .github/workflows/pr_build.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pr_build.yml b/.github/workflows/pr_build.yml index fb3498a..4b59efd 100644 --- a/.github/workflows/pr_build.yml +++ b/.github/workflows/pr_build.yml @@ -64,7 +64,8 @@ jobs: if [ "${{ runner.os }}" = "macOS" ]; then export MACOSX_DEPLOYMENT_TARGET="${{ matrix.os == 'macos-14' && 14 || 13.6 }}" fi - cmake .. -DMEOS=ON -DCMAKE_BUILD_TYPE=Release + cmake .. -DMEOS=ON -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=${{ matrix.ld_prefix }} make -j sudo make install From 841c9e89c8802b5df5ac46ea4dcba9a1ac13ffb3 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 12:21:35 +0200 Subject: [PATCH 07/11] Skip GEOSContextHandle_t signatures when building the CFFI cdef MEOS 1.3's reentrant GEOS API surfaces geos_get_context returning GEOSContextHandle_t, which is a forward-declared opaque type from geos_c.h that the cdef does not (and should not) try to materialise. Adding GEOSContextHandle_t alongside json_object in undefined_types makes build_header.py comment the signature out, the same treatment already applied to mfjson constructors. Without it, pip install fails with cffi.CDefError: cannot parse "extern GEOSContextHandle_t geos_get_context(void);". --- builder/build_header.py | 2 +- builder/meos.h | 356 ++++++++++++++++++++++------------------ 2 files changed, 200 insertions(+), 158 deletions(-) diff --git a/builder/build_header.py b/builder/build_header.py index e7c612a..70443d8 100644 --- a/builder/build_header.py +++ b/builder/build_header.py @@ -24,7 +24,7 @@ def get_defined_functions(library_path): def remove_undefined_functions(content, so_path): defined = get_defined_functions(so_path) - undefined_types = ["json_object"] + undefined_types = ["json_object", "GEOSContextHandle_t"] def remove_if_not_defined(m): function = m.group(0).split("(")[0].strip().split(" ")[-1].strip("*") diff --git a/builder/meos.h b/builder/meos.h index 4066b3f..13e2aae 100644 --- a/builder/meos.h +++ b/builder/meos.h @@ -24,6 +24,7 @@ typedef struct pj_ctx PJ_CONTEXT; //#include +//#include //#include typedef char *Pointer; @@ -76,6 +77,8 @@ extern char *timestamptz_out(TimestampTz t); +//#include "meos_tls.h" + typedef struct { int32 vl_len_; @@ -204,6 +207,24 @@ typedef struct typedef struct SkipList SkipList; +typedef struct MeosArray MeosArray; + +extern MeosArray *meos_array_create(int elem_size); +extern void meos_array_add(MeosArray *array, void *value); +extern void *meos_array_get(const MeosArray *array, int n); +extern int meos_array_count(const MeosArray *array); +extern void meos_array_reset(MeosArray *array); +extern void meos_array_reset_free(MeosArray *array); +extern void meos_array_destroy(MeosArray *array); +extern void meos_array_destroy_free(MeosArray *array); + +typedef enum +{ + RTREE_OVERLAPS, + RTREE_CONTAINS, + RTREE_CONTAINED_BY +} RTreeSearchOp; + typedef struct RTree RTree; extern RTree *rtree_create_intspan(); @@ -214,8 +235,10 @@ extern RTree *rtree_create_tstzspan(); extern RTree *rtree_create_tbox(); extern RTree *rtree_create_stbox(); extern void rtree_free(RTree *rtree); -extern void rtree_insert(RTree *rtree, void *box, int64 id); -extern int *rtree_search(const RTree *rtree,const void *query, int *count); +extern void rtree_insert(RTree *rtree, void *box, int id); +extern void rtree_insert_temporal(RTree *rtree, const Temporal *temp, int id); +extern int rtree_search(const RTree *rtree, RTreeSearchOp op, const void *query, MeosArray *result); +extern int rtree_search_temporal(const RTree *rtree, RTreeSearchOp op, const Temporal *temp, MeosArray *result); typedef enum { @@ -1496,6 +1519,8 @@ extern int nad_tint_tint(const Temporal *temp1, const Temporal *temp2); extern SkipList *tbool_tand_transfn(SkipList *state, const Temporal *temp); extern SkipList *tbool_tor_transfn(SkipList *state, const Temporal *temp); extern Span *temporal_extent_transfn(Span *s, const Temporal *temp); +extern SkipList *temporal_merge_transfn(SkipList *state, const Temporal *temp); +extern SkipList *temporal_merge_combinefn(SkipList *state1, SkipList *state2); extern Temporal *temporal_tagg_finalfn(SkipList *state); extern SkipList *temporal_tcount_transfn(SkipList *state, const Temporal *temp); extern SkipList *tfloat_tmax_transfn(SkipList *state, const Temporal *temp); @@ -1630,8 +1655,8 @@ typedef enum T_TGEOMETRY = 60, T_TGEOGRAPHY = 61, T_TRGEOMETRY = 62, - NO_MEOS_TYPES -} meosType; + NUM_MEOS_TYPES +} MeosType; typedef enum { @@ -1682,26 +1707,26 @@ typedef enum typedef struct { - meosType temptype; - meosType basetype; + MeosType temptype; + MeosType basetype; } temptype_catalog_struct; typedef struct { - meosType settype; - meosType basetype; + MeosType settype; + MeosType basetype; } settype_catalog_struct; typedef struct { - meosType spantype; - meosType basetype; + MeosType spantype; + MeosType basetype; } spantype_catalog_struct; typedef struct { - meosType spansettype; - meosType spantype; + MeosType spansettype; + MeosType spantype; } spansettype_catalog_struct; /* extern bool temptype_subtype(tempSubtype subtype); (undefined) */ @@ -1714,80 +1739,80 @@ extern meosOper meosoper_from_string(const char *name); extern const char *interptype_name(interpType interp); extern interpType interptype_from_string(const char *interp_str); -extern const char *meostype_name(meosType type); -extern meosType temptype_basetype(meosType type); -extern meosType settype_basetype(meosType type); -extern meosType spantype_basetype(meosType type); -extern meosType spantype_spansettype(meosType type); -extern meosType spansettype_spantype(meosType type); -extern meosType basetype_spantype(meosType type); -extern meosType basetype_settype(meosType type); - -extern bool tnumber_basetype(meosType type); -extern bool geo_basetype(meosType type); -/* extern bool meos_basetype(meosType type); (undefined) */ -/* extern bool alphanum_basetype(meosType type); (undefined) */ -/* extern bool alphanum_temptype(meosType type); (undefined) */ - -extern bool time_type(meosType type); -/* extern bool set_basetype(meosType type); (undefined) */ - -extern bool set_type(meosType type); -extern bool numset_type(meosType type); -extern bool ensure_numset_type(meosType type); -extern bool timeset_type(meosType type); -extern bool set_spantype(meosType type); -extern bool ensure_set_spantype(meosType type); -extern bool alphanumset_type(meosType settype); -extern bool geoset_type(meosType type); -extern bool ensure_geoset_type(meosType type); -extern bool spatialset_type(meosType type); -extern bool ensure_spatialset_type(meosType type); - -extern bool span_basetype(meosType type); -extern bool span_canon_basetype(meosType type); -extern bool span_type(meosType type); -extern bool type_span_bbox(meosType type); -extern bool span_tbox_type(meosType type); -extern bool ensure_span_tbox_type(meosType type); -extern bool numspan_basetype(meosType type); -extern bool numspan_type(meosType type); -extern bool ensure_numspan_type(meosType type); -extern bool timespan_basetype(meosType type); -extern bool timespan_type(meosType type); - -extern bool spanset_type(meosType type); -extern bool timespanset_type(meosType type); -extern bool ensure_timespanset_type(meosType type); - -extern bool temporal_type(meosType type); -/* extern bool temporal_basetype(meosType type); (undefined) */ - -extern bool temptype_continuous(meosType type); -extern bool basetype_byvalue(meosType type); -extern bool basetype_varlength(meosType type); -extern int16 basetype_length(meosType type); -/* extern bool talphanum_type(meosType type); (undefined) */ - -extern bool talpha_type(meosType type); -extern bool tnumber_type(meosType type); -extern bool ensure_tnumber_type(meosType type); -extern bool ensure_tnumber_basetype(meosType type); -extern bool tnumber_spantype(meosType type); -extern bool spatial_basetype(meosType type); -extern bool tspatial_type(meosType type); -extern bool ensure_tspatial_type(meosType type); -extern bool tpoint_type(meosType type); -extern bool ensure_tpoint_type(meosType type); -extern bool tgeo_type(meosType type); -extern bool ensure_tgeo_type(meosType type); -extern bool tgeo_type_all(meosType type); -extern bool ensure_tgeo_type_all(meosType type); -extern bool tgeometry_type(meosType type); -extern bool ensure_tgeometry_type(meosType type); -extern bool tgeodetic_type(meosType type); -extern bool ensure_tgeodetic_type(meosType type); -extern bool ensure_tnumber_tpoint_type(meosType type); +extern const char *meostype_name(MeosType type); +extern MeosType temptype_basetype(MeosType type); +extern MeosType settype_basetype(MeosType type); +extern MeosType spantype_basetype(MeosType type); +extern MeosType spantype_spansettype(MeosType type); +extern MeosType spansettype_spantype(MeosType type); +extern MeosType basetype_spantype(MeosType type); +extern MeosType basetype_settype(MeosType type); + +extern bool tnumber_basetype(MeosType type); +extern bool geo_basetype(MeosType type); +/* extern bool meos_basetype(MeosType type); (undefined) */ +/* extern bool alphanum_basetype(MeosType type); (undefined) */ +/* extern bool alphanum_temptype(MeosType type); (undefined) */ + +extern bool time_type(MeosType type); +/* extern bool set_basetype(MeosType type); (undefined) */ + +extern bool set_type(MeosType type); +extern bool numset_type(MeosType type); +extern bool ensure_numset_type(MeosType type); +extern bool timeset_type(MeosType type); +extern bool set_spantype(MeosType type); +extern bool ensure_set_spantype(MeosType type); +extern bool alphanumset_type(MeosType settype); +extern bool geoset_type(MeosType type); +extern bool ensure_geoset_type(MeosType type); +extern bool spatialset_type(MeosType type); +extern bool ensure_spatialset_type(MeosType type); + +extern bool span_basetype(MeosType type); +extern bool span_canon_basetype(MeosType type); +extern bool span_type(MeosType type); +extern bool type_span_bbox(MeosType type); +extern bool span_tbox_type(MeosType type); +extern bool ensure_span_tbox_type(MeosType type); +extern bool numspan_basetype(MeosType type); +extern bool numspan_type(MeosType type); +extern bool ensure_numspan_type(MeosType type); +extern bool timespan_basetype(MeosType type); +extern bool timespan_type(MeosType type); + +extern bool spanset_type(MeosType type); +extern bool timespanset_type(MeosType type); +extern bool ensure_timespanset_type(MeosType type); + +extern bool temporal_type(MeosType type); +/* extern bool temporal_basetype(MeosType type); (undefined) */ + +extern bool temptype_continuous(MeosType type); +extern bool basetype_byvalue(MeosType type); +extern bool basetype_varlength(MeosType type); +extern int16 meostype_length(MeosType type); +/* extern bool talphanum_type(MeosType type); (undefined) */ + +extern bool talpha_type(MeosType type); +extern bool tnumber_type(MeosType type); +extern bool ensure_tnumber_type(MeosType type); +extern bool ensure_tnumber_basetype(MeosType type); +extern bool tnumber_spantype(MeosType type); +extern bool spatial_basetype(MeosType type); +extern bool tspatial_type(MeosType type); +extern bool ensure_tspatial_type(MeosType type); +extern bool tpoint_type(MeosType type); +extern bool ensure_tpoint_type(MeosType type); +extern bool tgeo_type(MeosType type); +extern bool ensure_tgeo_type(MeosType type); +extern bool tgeo_type_all(MeosType type); +extern bool ensure_tgeo_type_all(MeosType type); +extern bool tgeometry_type(MeosType type); +extern bool ensure_tgeometry_type(MeosType type); +extern bool tgeodetic_type(MeosType type); +extern bool ensure_tgeodetic_type(MeosType type); +extern bool ensure_tnumber_tpoint_type(MeosType type); @@ -2448,9 +2473,11 @@ extern Temporal *tgeo_at_value(const Temporal *temp, GSERIALIZED *gs); extern Temporal *tgeo_minus_geom(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tgeo_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); extern Temporal *tgeo_minus_value(const Temporal *temp, GSERIALIZED *gs); -extern Temporal *tpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan); +extern Temporal *tpoint_at_elevation(const Temporal *temp, const Span *s); +extern Temporal *tpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tpoint_at_value(const Temporal *temp, GSERIALIZED *gs); -extern Temporal *tpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan); +extern Temporal *tpoint_minus_elevation(const Temporal *temp, const Span *s); +extern Temporal *tpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tpoint_minus_value(const Temporal *temp, GSERIALIZED *gs); extern int always_eq_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); @@ -2570,24 +2597,24 @@ extern int etouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); extern int etouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); extern int etouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tcontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); -extern Temporal *tcontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); -extern Temporal *tcontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); -extern Temporal *tcovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); -extern Temporal *tcovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); -extern Temporal *tcovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); -extern Temporal *tdisjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); -extern Temporal *tdisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); -extern Temporal *tdisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); -extern Temporal *tdwithin_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, double dist, bool restr, bool atvalue); -extern Temporal *tdwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist, bool restr, bool atvalue); -extern Temporal *tdwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist, bool restr, bool atvalue); -extern Temporal *tintersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); -extern Temporal *tintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); -extern Temporal *tintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); -extern Temporal *ttouches_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); -extern Temporal *ttouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); -extern Temporal *ttouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); +extern Temporal *tcontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tcovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdisjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tdisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdwithin_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, double dist); +extern Temporal *tdwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern Temporal *tdwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist); +extern Temporal *tintersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *ttouches_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *ttouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *ttouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); extern Temporal *tdistance_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tdistance_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); @@ -2723,6 +2750,16 @@ extern GSERIALIZED **geo_cluster_within(const GSERIALIZED **geoms, uint32_t ngeo +#define MEOS_ARRAY_INITIAL_SIZE 256 +typedef struct MeosArray +{ + size_t capacity; + size_t count; + size_t elem_size; + bool varlength; + void *elems; +} MeosArray; + #define SKIPLIST_MAXLEVEL 32 typedef struct { @@ -2769,32 +2806,32 @@ extern Datum datum_ceil(Datum d); extern Datum datum_degrees(Datum d, Datum normalize); extern Datum datum_float_round(Datum value, Datum size); extern Datum datum_floor(Datum d); -extern uint32 datum_hash(Datum d, meosType basetype); -extern uint64 datum_hash_extended(Datum d, meosType basetype, uint64 seed); +extern uint32 datum_hash(Datum d, MeosType basetype); +extern uint64 datum_hash_extended(Datum d, MeosType basetype, uint64 seed); extern Datum datum_radians(Datum d); extern void floatspan_round_set(const Span *s, int maxdd, Span *result); -extern Set *set_in(const char *str, meosType basetype); +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); +extern Span *span_in(const char *str, MeosType spantype); extern char *span_out(const Span *s, int maxdd); -extern SpanSet *spanset_in(const char *str, meosType spantype); +extern SpanSet *spanset_in(const char *str, MeosType spantype); extern char *spanset_out(const SpanSet *ss, int maxdd); -extern Set *set_make(const Datum *values, int count, meosType basetype, bool order); -extern Set *set_make_exp(const Datum *values, int count, int maxcount, meosType basetype, bool order); -extern Set *set_make_free(Datum *values, int count, meosType basetype, bool order); -extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype); -extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype, meosType spantype, Span *s); +extern Set *set_make(const Datum *values, int count, MeosType basetype, bool order); +extern Set *set_make_exp(const Datum *values, int count, int maxcount, MeosType basetype, bool order); +extern Set *set_make_free(Datum *values, int count, MeosType basetype, bool order); +extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype); +extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype, MeosType spantype, Span *s); extern SpanSet *spanset_make_exp(Span *spans, int count, int maxcount, bool normalize, bool order); extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize, bool order); extern Span *set_span(const Set *s); extern SpanSet *set_spanset(const Set *s); -extern void value_set_span(Datum value, meosType basetype, Span *s); -extern Set *value_set(Datum d, meosType basetype); -extern Span *value_span(Datum d, meosType basetype); -extern SpanSet *value_spanset(Datum d, meosType basetype); +extern void value_set_span(Datum value, MeosType basetype, Span *s); +extern Set *value_set(Datum d, MeosType basetype); +extern Span *value_span(Datum d, MeosType basetype); +extern SpanSet *value_spanset(Datum d, MeosType basetype); extern Datum numspan_width(const Span *s); extern Datum numspanset_width(const SpanSet *ss, bool boundspan); @@ -2821,7 +2858,7 @@ extern SpanSet *numspanset_shift_scale(const SpanSet *ss, Datum shift, Datum wid extern Set *set_compact(const Set *s); extern void span_expand(const Span *s1, Span *s2); extern SpanSet *spanset_compact(const SpanSet *ss); -extern TBox *tbox_expand_value(const TBox *box, Datum value, meosType basetyp); +extern TBox *tbox_expand_value(const TBox *box, Datum value, MeosType basetyp); extern Set *textcat_textset_text_common(const Set *s, const text *txt, bool invert); extern void tstzspan_set_datespan(const Span *s1, Span *s2); @@ -2862,13 +2899,13 @@ 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 bool bbox_type(meosType bboxtype); -extern size_t bbox_get_size(meosType bboxtype); -extern int bbox_max_dims(meosType bboxtype); +extern bool bbox_type(MeosType bboxtype); +extern size_t bbox_get_size(MeosType bboxtype); +extern int bbox_max_dims(MeosType bboxtype); extern bool temporal_bbox_eq(const void *box1, const void *box2, - meosType temptype); + MeosType temptype); extern int temporal_bbox_cmp(const void *box1, const void *box2, - meosType temptype); + MeosType temptype); 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); @@ -2900,19 +2937,19 @@ 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 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 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); +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); extern void tbox_set(const Span *s, const Span *p, TBox *box); extern void float_set_tbox(double d, TBox *box); extern void int_set_tbox(int i, TBox *box); -extern void number_set_tbox(Datum d, meosType basetype, TBox *box); -extern TBox *number_tbox(Datum value, meosType basetype); +extern void number_set_tbox(Datum d, MeosType basetype, TBox *box); +extern TBox *number_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 timestamptz_set_tbox(TimestampTz t, TBox *box); @@ -2930,7 +2967,7 @@ extern TInstant *tboolinst_in(const char *str); extern TSequence *tboolseq_in(const char *str, interpType interp); /* extern TSequenceSet *tboolseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *tboolseqset_in(const char *str); -extern Temporal *temporal_in(const char *str, meosType temptype); +extern Temporal *temporal_in(const char *str, MeosType temptype); extern char *temporal_out(const Temporal *temp, int maxdd); extern char **temparr_out(Temporal **temparr, int count, int maxdd); /* extern TInstant *tfloatinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ @@ -2939,8 +2976,8 @@ extern TInstant *tfloatinst_in(const char *str); extern TSequence *tfloatseq_in(const char *str, interpType interp); /* extern TSequenceSet *tfloatseqset_from_mfjson(json_object *mfjson, interpType interp); (undefined type json_object) */ extern TSequenceSet *tfloatseqset_in(const char *str); -/* extern TInstant *tinstant_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype); (undefined type json_object) */ -extern TInstant *tinstant_in(const char *str, meosType temptype); +/* extern TInstant *tinstant_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype); (undefined type json_object) */ +extern TInstant *tinstant_in(const char *str, MeosType temptype); extern char *tinstant_out(const TInstant *inst, int maxdd); /* extern TInstant *tintinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *tintinst_in(const char *str); @@ -2948,11 +2985,11 @@ extern TInstant *tintinst_in(const char *str); extern TSequence *tintseq_in(const char *str, interpType interp); /* extern TSequenceSet *tintseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *tintseqset_in(const char *str); -/* extern TSequence *tsequence_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype, interpType interp); (undefined type json_object) */ -extern TSequence *tsequence_in(const char *str, meosType temptype, interpType interp); +/* extern TSequence *tsequence_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); (undefined type json_object) */ +extern TSequence *tsequence_in(const char *str, MeosType temptype, interpType interp); extern char *tsequence_out(const TSequence *seq, int maxdd); -/* extern TSequenceSet *tsequenceset_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype, interpType interp); (undefined type json_object) */ -extern TSequenceSet *tsequenceset_in(const char *str, meosType temptype, interpType interp); +/* extern TSequenceSet *tsequenceset_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); (undefined type json_object) */ +extern TSequenceSet *tsequenceset_in(const char *str, MeosType temptype, interpType interp); extern char *tsequenceset_out(const TSequenceSet *ss, int maxdd); /* extern TInstant *ttextinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *ttextinst_in(const char *str); @@ -2960,22 +2997,22 @@ extern TInstant *ttextinst_in(const char *str); extern TSequence *ttextseq_in(const char *str, interpType interp); /* 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_from_mfjson(const char *mfjson, MeosType temptype); -extern Temporal *temporal_from_base_temp(Datum value, meosType temptype, 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 TInstant *tinstant_make(Datum value, MeosType temptype, TimestampTz t); +extern TInstant *tinstant_make_free(Datum value, MeosType temptype, TimestampTz t); extern TSequence *tsequence_copy(const TSequence *seq); -extern TSequence *tsequence_from_base_temp(Datum value, meosType temptype, const TSequence *seq); -extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *s); -extern TSequence *tsequence_from_base_tstzspan(Datum value, meosType temptype, const Span *s, interpType interp); +extern TSequence *tsequence_from_base_temp(Datum value, MeosType temptype, const TSequence *seq); +extern TSequence *tsequence_from_base_tstzset(Datum value, MeosType temptype, const Set *s); +extern TSequence *tsequence_from_base_tstzspan(Datum value, MeosType temptype, const Span *s, interpType interp); extern TSequence *tsequence_make_exp(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_copy(const TSequenceSet *ss); extern TSequenceSet *tseqsetarr_to_tseqset(TSequenceSet **seqsets, int count, int totalseqs); -extern TSequenceSet *tsequenceset_from_base_temp(Datum value, meosType temptype, const TSequenceSet *ss); -extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, meosType temptype, const SpanSet *ss, interpType interp); +extern TSequenceSet *tsequenceset_from_base_temp(Datum value, MeosType temptype, const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, MeosType temptype, const SpanSet *ss, interpType interp); extern TSequenceSet *tsequenceset_make_exp(TSequence **sequences, int count, int maxcount, bool normalize); extern TSequenceSet *tsequenceset_make_free(TSequence **sequences, int count, bool normalize); @@ -3224,7 +3261,7 @@ extern Span *spanset_bins(const SpanSet *ss, Datum size, Datum origin, int *coun extern Span *tnumber_value_bins(const Temporal *temp, Datum size, Datum origin, int *count); extern TBox *tnumber_value_time_boxes(const Temporal *temp, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, int *count); extern Temporal **tnumber_value_split(const Temporal *temp, Datum vsize, Datum vorigin, Datum **bins, int *count); -extern TBox *tbox_get_value_time_tile(Datum value, TimestampTz t, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, meosType basetype, meosType spantype); +extern TBox *tbox_get_value_time_tile(Datum value, TimestampTz t, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, MeosType basetype, MeosType spantype); extern Temporal **tnumber_value_time_split(const Temporal *temp, Datum size, const Interval *duration, Datum vorigin, TimestampTz torigin, Datum **value_bins, TimestampTz **time_bins, int *count); @@ -3237,12 +3274,16 @@ extern Temporal **tnumber_value_time_split(const Temporal *temp, Datum size, con //#include +//#include + //#include //#include //#include extern PJ_CONTEXT *proj_get_context(void); +/* extern GEOSContextHandle_t geos_get_context(void); (undefined type GEOSContextHandle_t) */ + extern Datum datum_geo_round(Datum value, Datum size); extern GSERIALIZED *point_round(const GSERIALIZED *gs, int maxdd); @@ -3251,7 +3292,7 @@ extern void stbox_set(bool hasx, bool hasz, bool geodetic, int32 srid, double xm extern void gbox_set_stbox(const GBOX *box, int32_t srid, STBox *result); extern bool geo_set_stbox(const GSERIALIZED *gs, STBox *box); extern void geoarr_set_stbox(const Datum *values, int count, STBox *box); -extern bool spatial_set_stbox(Datum d, meosType basetype, STBox *box); +extern bool spatial_set_stbox(Datum d, MeosType basetype, STBox *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); @@ -3294,17 +3335,18 @@ extern void tgeoinst_set_stbox(const TInstant *inst, STBox *box); extern void tspatialseq_set_stbox(const TSequence *seq, STBox *box); extern void tspatialseqset_set_stbox(const TSequenceSet *ss, STBox *box); -extern Temporal *tgeo_restrict_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan, bool atfunc); +extern Temporal *tgeo_restrict_elevation(const Temporal *temp, const Span *s, bool atfunc); +extern Temporal *tgeo_restrict_geom(const Temporal *temp, const GSERIALIZED *gs, bool atfunc); extern Temporal *tgeo_restrict_stbox(const Temporal *temp, const STBox *box, bool border_inc, bool atfunc); -extern TInstant *tgeoinst_restrict_geom(const TInstant *inst, const GSERIALIZED *gs, const Span *zspan, bool atfunc); +extern TInstant *tgeoinst_restrict_geom(const TInstant *inst, const GSERIALIZED *gs, bool atfunc); extern TInstant *tgeoinst_restrict_stbox(const TInstant *inst, const STBox *box, bool border_inc, bool atfunc); -extern Temporal *tgeoseq_restrict_geom(const TSequence *seq, const GSERIALIZED *gs, const Span *zspan, bool atfunc); +extern Temporal *tgeoseq_restrict_geom(const TSequence *seq, const GSERIALIZED *gs, bool atfunc); extern Temporal *tgeoseq_restrict_stbox(const TSequence *seq, const STBox *box, bool border_inc, bool atfunc); -extern TSequenceSet *tgeoseqset_restrict_geom(const TSequenceSet *ss, const GSERIALIZED *gs, const Span *zspan, bool atfunc); +extern TSequenceSet *tgeoseqset_restrict_geom(const TSequenceSet *ss, const GSERIALIZED *gs, bool atfunc); extern TSequenceSet *tgeoseqset_restrict_stbox(const TSequenceSet *ss, const STBox *box, bool border_inc, bool atfunc); -extern int32_t spatial_srid(Datum d, meosType basetype); -extern bool spatial_set_srid(Datum d, meosType basetype, int32_t srid); +extern int32_t spatial_srid(Datum d, MeosType basetype); +extern bool spatial_set_srid(Datum d, MeosType basetype, int32_t srid); extern int tspatialinst_srid(const TInstant *inst); extern TSequenceSet *tpointseq_azimuth(const TSequence *seq); extern TSequence *tpointseq_cumulative_length(const TSequence *seq, double prevlength); From fa4c75d08488347d63c53bae05f4663bd11ff561 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 13 May 2026 15:39:26 +0200 Subject: [PATCH 08/11] Revert builder/meos.h to the stable-1.3 regen Commit 841c9e8 regenerated builder/meos.h against a local MEOS install that was ahead of stable-1.3 (the branch CI actually checks out), which introduced references to MeosArray, MeosType and RTreeSearchOp that the installed library does not declare and made the Linux and macOS-14 builds fail with undefined-type errors during the cffi wheel compile. The build_header.py change in 841c9e8 stays in place so the GEOS handle stub still applies when MEOS later acquires geos_get_context, but the cdef header is brought back to the stable-1.3 view that build_header.py produced two commits earlier. --- builder/meos.h | 356 ++++++++++++++++++++++--------------------------- 1 file changed, 157 insertions(+), 199 deletions(-) diff --git a/builder/meos.h b/builder/meos.h index 13e2aae..4066b3f 100644 --- a/builder/meos.h +++ b/builder/meos.h @@ -24,7 +24,6 @@ typedef struct pj_ctx PJ_CONTEXT; //#include -//#include //#include typedef char *Pointer; @@ -77,8 +76,6 @@ extern char *timestamptz_out(TimestampTz t); -//#include "meos_tls.h" - typedef struct { int32 vl_len_; @@ -207,24 +204,6 @@ typedef struct typedef struct SkipList SkipList; -typedef struct MeosArray MeosArray; - -extern MeosArray *meos_array_create(int elem_size); -extern void meos_array_add(MeosArray *array, void *value); -extern void *meos_array_get(const MeosArray *array, int n); -extern int meos_array_count(const MeosArray *array); -extern void meos_array_reset(MeosArray *array); -extern void meos_array_reset_free(MeosArray *array); -extern void meos_array_destroy(MeosArray *array); -extern void meos_array_destroy_free(MeosArray *array); - -typedef enum -{ - RTREE_OVERLAPS, - RTREE_CONTAINS, - RTREE_CONTAINED_BY -} RTreeSearchOp; - typedef struct RTree RTree; extern RTree *rtree_create_intspan(); @@ -235,10 +214,8 @@ extern RTree *rtree_create_tstzspan(); extern RTree *rtree_create_tbox(); extern RTree *rtree_create_stbox(); extern void rtree_free(RTree *rtree); -extern void rtree_insert(RTree *rtree, void *box, int id); -extern void rtree_insert_temporal(RTree *rtree, const Temporal *temp, int id); -extern int rtree_search(const RTree *rtree, RTreeSearchOp op, const void *query, MeosArray *result); -extern int rtree_search_temporal(const RTree *rtree, RTreeSearchOp op, const Temporal *temp, MeosArray *result); +extern void rtree_insert(RTree *rtree, void *box, int64 id); +extern int *rtree_search(const RTree *rtree,const void *query, int *count); typedef enum { @@ -1519,8 +1496,6 @@ extern int nad_tint_tint(const Temporal *temp1, const Temporal *temp2); extern SkipList *tbool_tand_transfn(SkipList *state, const Temporal *temp); extern SkipList *tbool_tor_transfn(SkipList *state, const Temporal *temp); extern Span *temporal_extent_transfn(Span *s, const Temporal *temp); -extern SkipList *temporal_merge_transfn(SkipList *state, const Temporal *temp); -extern SkipList *temporal_merge_combinefn(SkipList *state1, SkipList *state2); extern Temporal *temporal_tagg_finalfn(SkipList *state); extern SkipList *temporal_tcount_transfn(SkipList *state, const Temporal *temp); extern SkipList *tfloat_tmax_transfn(SkipList *state, const Temporal *temp); @@ -1655,8 +1630,8 @@ typedef enum T_TGEOMETRY = 60, T_TGEOGRAPHY = 61, T_TRGEOMETRY = 62, - NUM_MEOS_TYPES -} MeosType; + NO_MEOS_TYPES +} meosType; typedef enum { @@ -1707,26 +1682,26 @@ typedef enum typedef struct { - MeosType temptype; - MeosType basetype; + meosType temptype; + meosType basetype; } temptype_catalog_struct; typedef struct { - MeosType settype; - MeosType basetype; + meosType settype; + meosType basetype; } settype_catalog_struct; typedef struct { - MeosType spantype; - MeosType basetype; + meosType spantype; + meosType basetype; } spantype_catalog_struct; typedef struct { - MeosType spansettype; - MeosType spantype; + meosType spansettype; + meosType spantype; } spansettype_catalog_struct; /* extern bool temptype_subtype(tempSubtype subtype); (undefined) */ @@ -1739,80 +1714,80 @@ extern meosOper meosoper_from_string(const char *name); extern const char *interptype_name(interpType interp); extern interpType interptype_from_string(const char *interp_str); -extern const char *meostype_name(MeosType type); -extern MeosType temptype_basetype(MeosType type); -extern MeosType settype_basetype(MeosType type); -extern MeosType spantype_basetype(MeosType type); -extern MeosType spantype_spansettype(MeosType type); -extern MeosType spansettype_spantype(MeosType type); -extern MeosType basetype_spantype(MeosType type); -extern MeosType basetype_settype(MeosType type); - -extern bool tnumber_basetype(MeosType type); -extern bool geo_basetype(MeosType type); -/* extern bool meos_basetype(MeosType type); (undefined) */ -/* extern bool alphanum_basetype(MeosType type); (undefined) */ -/* extern bool alphanum_temptype(MeosType type); (undefined) */ - -extern bool time_type(MeosType type); -/* extern bool set_basetype(MeosType type); (undefined) */ - -extern bool set_type(MeosType type); -extern bool numset_type(MeosType type); -extern bool ensure_numset_type(MeosType type); -extern bool timeset_type(MeosType type); -extern bool set_spantype(MeosType type); -extern bool ensure_set_spantype(MeosType type); -extern bool alphanumset_type(MeosType settype); -extern bool geoset_type(MeosType type); -extern bool ensure_geoset_type(MeosType type); -extern bool spatialset_type(MeosType type); -extern bool ensure_spatialset_type(MeosType type); - -extern bool span_basetype(MeosType type); -extern bool span_canon_basetype(MeosType type); -extern bool span_type(MeosType type); -extern bool type_span_bbox(MeosType type); -extern bool span_tbox_type(MeosType type); -extern bool ensure_span_tbox_type(MeosType type); -extern bool numspan_basetype(MeosType type); -extern bool numspan_type(MeosType type); -extern bool ensure_numspan_type(MeosType type); -extern bool timespan_basetype(MeosType type); -extern bool timespan_type(MeosType type); - -extern bool spanset_type(MeosType type); -extern bool timespanset_type(MeosType type); -extern bool ensure_timespanset_type(MeosType type); - -extern bool temporal_type(MeosType type); -/* extern bool temporal_basetype(MeosType type); (undefined) */ - -extern bool temptype_continuous(MeosType type); -extern bool basetype_byvalue(MeosType type); -extern bool basetype_varlength(MeosType type); -extern int16 meostype_length(MeosType type); -/* extern bool talphanum_type(MeosType type); (undefined) */ - -extern bool talpha_type(MeosType type); -extern bool tnumber_type(MeosType type); -extern bool ensure_tnumber_type(MeosType type); -extern bool ensure_tnumber_basetype(MeosType type); -extern bool tnumber_spantype(MeosType type); -extern bool spatial_basetype(MeosType type); -extern bool tspatial_type(MeosType type); -extern bool ensure_tspatial_type(MeosType type); -extern bool tpoint_type(MeosType type); -extern bool ensure_tpoint_type(MeosType type); -extern bool tgeo_type(MeosType type); -extern bool ensure_tgeo_type(MeosType type); -extern bool tgeo_type_all(MeosType type); -extern bool ensure_tgeo_type_all(MeosType type); -extern bool tgeometry_type(MeosType type); -extern bool ensure_tgeometry_type(MeosType type); -extern bool tgeodetic_type(MeosType type); -extern bool ensure_tgeodetic_type(MeosType type); -extern bool ensure_tnumber_tpoint_type(MeosType type); +extern const char *meostype_name(meosType type); +extern meosType temptype_basetype(meosType type); +extern meosType settype_basetype(meosType type); +extern meosType spantype_basetype(meosType type); +extern meosType spantype_spansettype(meosType type); +extern meosType spansettype_spantype(meosType type); +extern meosType basetype_spantype(meosType type); +extern meosType basetype_settype(meosType type); + +extern bool tnumber_basetype(meosType type); +extern bool geo_basetype(meosType type); +/* extern bool meos_basetype(meosType type); (undefined) */ +/* extern bool alphanum_basetype(meosType type); (undefined) */ +/* extern bool alphanum_temptype(meosType type); (undefined) */ + +extern bool time_type(meosType type); +/* extern bool set_basetype(meosType type); (undefined) */ + +extern bool set_type(meosType type); +extern bool numset_type(meosType type); +extern bool ensure_numset_type(meosType type); +extern bool timeset_type(meosType type); +extern bool set_spantype(meosType type); +extern bool ensure_set_spantype(meosType type); +extern bool alphanumset_type(meosType settype); +extern bool geoset_type(meosType type); +extern bool ensure_geoset_type(meosType type); +extern bool spatialset_type(meosType type); +extern bool ensure_spatialset_type(meosType type); + +extern bool span_basetype(meosType type); +extern bool span_canon_basetype(meosType type); +extern bool span_type(meosType type); +extern bool type_span_bbox(meosType type); +extern bool span_tbox_type(meosType type); +extern bool ensure_span_tbox_type(meosType type); +extern bool numspan_basetype(meosType type); +extern bool numspan_type(meosType type); +extern bool ensure_numspan_type(meosType type); +extern bool timespan_basetype(meosType type); +extern bool timespan_type(meosType type); + +extern bool spanset_type(meosType type); +extern bool timespanset_type(meosType type); +extern bool ensure_timespanset_type(meosType type); + +extern bool temporal_type(meosType type); +/* extern bool temporal_basetype(meosType type); (undefined) */ + +extern bool temptype_continuous(meosType type); +extern bool basetype_byvalue(meosType type); +extern bool basetype_varlength(meosType type); +extern int16 basetype_length(meosType type); +/* extern bool talphanum_type(meosType type); (undefined) */ + +extern bool talpha_type(meosType type); +extern bool tnumber_type(meosType type); +extern bool ensure_tnumber_type(meosType type); +extern bool ensure_tnumber_basetype(meosType type); +extern bool tnumber_spantype(meosType type); +extern bool spatial_basetype(meosType type); +extern bool tspatial_type(meosType type); +extern bool ensure_tspatial_type(meosType type); +extern bool tpoint_type(meosType type); +extern bool ensure_tpoint_type(meosType type); +extern bool tgeo_type(meosType type); +extern bool ensure_tgeo_type(meosType type); +extern bool tgeo_type_all(meosType type); +extern bool ensure_tgeo_type_all(meosType type); +extern bool tgeometry_type(meosType type); +extern bool ensure_tgeometry_type(meosType type); +extern bool tgeodetic_type(meosType type); +extern bool ensure_tgeodetic_type(meosType type); +extern bool ensure_tnumber_tpoint_type(meosType type); @@ -2473,11 +2448,9 @@ extern Temporal *tgeo_at_value(const Temporal *temp, GSERIALIZED *gs); extern Temporal *tgeo_minus_geom(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tgeo_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); extern Temporal *tgeo_minus_value(const Temporal *temp, GSERIALIZED *gs); -extern Temporal *tpoint_at_elevation(const Temporal *temp, const Span *s); -extern Temporal *tpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan); extern Temporal *tpoint_at_value(const Temporal *temp, GSERIALIZED *gs); -extern Temporal *tpoint_minus_elevation(const Temporal *temp, const Span *s); -extern Temporal *tpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan); extern Temporal *tpoint_minus_value(const Temporal *temp, GSERIALIZED *gs); extern int always_eq_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); @@ -2597,24 +2570,24 @@ extern int etouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); extern int etouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); extern int etouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tcontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); -extern Temporal *tcontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tcontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); -extern Temporal *tcovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); -extern Temporal *tcovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tcovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); -extern Temporal *tdisjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); -extern Temporal *tdisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tdisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); -extern Temporal *tdwithin_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, double dist); -extern Temporal *tdwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); -extern Temporal *tdwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist); -extern Temporal *tintersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); -extern Temporal *tintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); -extern Temporal *ttouches_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); -extern Temporal *ttouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *ttouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tcontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); +extern Temporal *tcontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tcontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); +extern Temporal *tcovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); +extern Temporal *tcovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tcovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); +extern Temporal *tdisjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); +extern Temporal *tdisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tdisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); +extern Temporal *tdwithin_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, double dist, bool restr, bool atvalue); +extern Temporal *tdwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist, bool restr, bool atvalue); +extern Temporal *tdwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist, bool restr, bool atvalue); +extern Temporal *tintersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); +extern Temporal *tintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); +extern Temporal *ttouches_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); +extern Temporal *ttouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *ttouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); extern Temporal *tdistance_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tdistance_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); @@ -2750,16 +2723,6 @@ extern GSERIALIZED **geo_cluster_within(const GSERIALIZED **geoms, uint32_t ngeo -#define MEOS_ARRAY_INITIAL_SIZE 256 -typedef struct MeosArray -{ - size_t capacity; - size_t count; - size_t elem_size; - bool varlength; - void *elems; -} MeosArray; - #define SKIPLIST_MAXLEVEL 32 typedef struct { @@ -2806,32 +2769,32 @@ extern Datum datum_ceil(Datum d); extern Datum datum_degrees(Datum d, Datum normalize); extern Datum datum_float_round(Datum value, Datum size); extern Datum datum_floor(Datum d); -extern uint32 datum_hash(Datum d, MeosType basetype); -extern uint64 datum_hash_extended(Datum d, MeosType basetype, uint64 seed); +extern uint32 datum_hash(Datum d, meosType basetype); +extern uint64 datum_hash_extended(Datum d, meosType basetype, uint64 seed); extern Datum datum_radians(Datum d); extern void floatspan_round_set(const Span *s, int maxdd, Span *result); -extern Set *set_in(const char *str, MeosType basetype); +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); +extern Span *span_in(const char *str, meosType spantype); extern char *span_out(const Span *s, int maxdd); -extern SpanSet *spanset_in(const char *str, MeosType spantype); +extern SpanSet *spanset_in(const char *str, meosType spantype); extern char *spanset_out(const SpanSet *ss, int maxdd); -extern Set *set_make(const Datum *values, int count, MeosType basetype, bool order); -extern Set *set_make_exp(const Datum *values, int count, int maxcount, MeosType basetype, bool order); -extern Set *set_make_free(Datum *values, int count, MeosType basetype, bool order); -extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype); -extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype, MeosType spantype, Span *s); +extern Set *set_make(const Datum *values, int count, meosType basetype, bool order); +extern Set *set_make_exp(const Datum *values, int count, int maxcount, meosType basetype, bool order); +extern Set *set_make_free(Datum *values, int count, meosType basetype, bool order); +extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype); +extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype, meosType spantype, Span *s); extern SpanSet *spanset_make_exp(Span *spans, int count, int maxcount, bool normalize, bool order); extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize, bool order); extern Span *set_span(const Set *s); extern SpanSet *set_spanset(const Set *s); -extern void value_set_span(Datum value, MeosType basetype, Span *s); -extern Set *value_set(Datum d, MeosType basetype); -extern Span *value_span(Datum d, MeosType basetype); -extern SpanSet *value_spanset(Datum d, MeosType basetype); +extern void value_set_span(Datum value, meosType basetype, Span *s); +extern Set *value_set(Datum d, meosType basetype); +extern Span *value_span(Datum d, meosType basetype); +extern SpanSet *value_spanset(Datum d, meosType basetype); extern Datum numspan_width(const Span *s); extern Datum numspanset_width(const SpanSet *ss, bool boundspan); @@ -2858,7 +2821,7 @@ extern SpanSet *numspanset_shift_scale(const SpanSet *ss, Datum shift, Datum wid extern Set *set_compact(const Set *s); extern void span_expand(const Span *s1, Span *s2); extern SpanSet *spanset_compact(const SpanSet *ss); -extern TBox *tbox_expand_value(const TBox *box, Datum value, MeosType basetyp); +extern TBox *tbox_expand_value(const TBox *box, Datum value, meosType basetyp); extern Set *textcat_textset_text_common(const Set *s, const text *txt, bool invert); extern void tstzspan_set_datespan(const Span *s1, Span *s2); @@ -2899,13 +2862,13 @@ 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 bool bbox_type(MeosType bboxtype); -extern size_t bbox_get_size(MeosType bboxtype); -extern int bbox_max_dims(MeosType bboxtype); +extern bool bbox_type(meosType bboxtype); +extern size_t bbox_get_size(meosType bboxtype); +extern int bbox_max_dims(meosType bboxtype); extern bool temporal_bbox_eq(const void *box1, const void *box2, - MeosType temptype); + meosType temptype); extern int temporal_bbox_cmp(const void *box1, const void *box2, - MeosType temptype); + meosType temptype); 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); @@ -2937,19 +2900,19 @@ 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 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 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); +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); extern void tbox_set(const Span *s, const Span *p, TBox *box); extern void float_set_tbox(double d, TBox *box); extern void int_set_tbox(int i, TBox *box); -extern void number_set_tbox(Datum d, MeosType basetype, TBox *box); -extern TBox *number_tbox(Datum value, MeosType basetype); +extern void number_set_tbox(Datum d, meosType basetype, TBox *box); +extern TBox *number_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 timestamptz_set_tbox(TimestampTz t, TBox *box); @@ -2967,7 +2930,7 @@ extern TInstant *tboolinst_in(const char *str); extern TSequence *tboolseq_in(const char *str, interpType interp); /* extern TSequenceSet *tboolseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *tboolseqset_in(const char *str); -extern Temporal *temporal_in(const char *str, MeosType temptype); +extern Temporal *temporal_in(const char *str, meosType temptype); extern char *temporal_out(const Temporal *temp, int maxdd); extern char **temparr_out(Temporal **temparr, int count, int maxdd); /* extern TInstant *tfloatinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ @@ -2976,8 +2939,8 @@ extern TInstant *tfloatinst_in(const char *str); extern TSequence *tfloatseq_in(const char *str, interpType interp); /* extern TSequenceSet *tfloatseqset_from_mfjson(json_object *mfjson, interpType interp); (undefined type json_object) */ extern TSequenceSet *tfloatseqset_in(const char *str); -/* extern TInstant *tinstant_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype); (undefined type json_object) */ -extern TInstant *tinstant_in(const char *str, MeosType temptype); +/* extern TInstant *tinstant_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype); (undefined type json_object) */ +extern TInstant *tinstant_in(const char *str, meosType temptype); extern char *tinstant_out(const TInstant *inst, int maxdd); /* extern TInstant *tintinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *tintinst_in(const char *str); @@ -2985,11 +2948,11 @@ extern TInstant *tintinst_in(const char *str); extern TSequence *tintseq_in(const char *str, interpType interp); /* extern TSequenceSet *tintseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *tintseqset_in(const char *str); -/* extern TSequence *tsequence_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); (undefined type json_object) */ -extern TSequence *tsequence_in(const char *str, MeosType temptype, interpType interp); +/* extern TSequence *tsequence_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype, interpType interp); (undefined type json_object) */ +extern TSequence *tsequence_in(const char *str, meosType temptype, interpType interp); extern char *tsequence_out(const TSequence *seq, int maxdd); -/* extern TSequenceSet *tsequenceset_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); (undefined type json_object) */ -extern TSequenceSet *tsequenceset_in(const char *str, MeosType temptype, interpType interp); +/* extern TSequenceSet *tsequenceset_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, meosType temptype, interpType interp); (undefined type json_object) */ +extern TSequenceSet *tsequenceset_in(const char *str, meosType temptype, interpType interp); extern char *tsequenceset_out(const TSequenceSet *ss, int maxdd); /* extern TInstant *ttextinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *ttextinst_in(const char *str); @@ -2997,22 +2960,22 @@ extern TInstant *ttextinst_in(const char *str); extern TSequence *ttextseq_in(const char *str, interpType interp); /* 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_from_mfjson(const char *mfjson, meosType temptype); -extern Temporal *temporal_from_base_temp(Datum value, MeosType temptype, 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 TInstant *tinstant_make(Datum value, meosType temptype, TimestampTz t); +extern TInstant *tinstant_make_free(Datum value, meosType temptype, TimestampTz t); extern TSequence *tsequence_copy(const TSequence *seq); -extern TSequence *tsequence_from_base_temp(Datum value, MeosType temptype, const TSequence *seq); -extern TSequence *tsequence_from_base_tstzset(Datum value, MeosType temptype, const Set *s); -extern TSequence *tsequence_from_base_tstzspan(Datum value, MeosType temptype, const Span *s, interpType interp); +extern TSequence *tsequence_from_base_temp(Datum value, meosType temptype, const TSequence *seq); +extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *s); +extern TSequence *tsequence_from_base_tstzspan(Datum value, meosType temptype, const Span *s, interpType interp); extern TSequence *tsequence_make_exp(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_copy(const TSequenceSet *ss); extern TSequenceSet *tseqsetarr_to_tseqset(TSequenceSet **seqsets, int count, int totalseqs); -extern TSequenceSet *tsequenceset_from_base_temp(Datum value, MeosType temptype, const TSequenceSet *ss); -extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, MeosType temptype, const SpanSet *ss, interpType interp); +extern TSequenceSet *tsequenceset_from_base_temp(Datum value, meosType temptype, const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, meosType temptype, const SpanSet *ss, interpType interp); extern TSequenceSet *tsequenceset_make_exp(TSequence **sequences, int count, int maxcount, bool normalize); extern TSequenceSet *tsequenceset_make_free(TSequence **sequences, int count, bool normalize); @@ -3261,7 +3224,7 @@ extern Span *spanset_bins(const SpanSet *ss, Datum size, Datum origin, int *coun extern Span *tnumber_value_bins(const Temporal *temp, Datum size, Datum origin, int *count); extern TBox *tnumber_value_time_boxes(const Temporal *temp, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, int *count); extern Temporal **tnumber_value_split(const Temporal *temp, Datum vsize, Datum vorigin, Datum **bins, int *count); -extern TBox *tbox_get_value_time_tile(Datum value, TimestampTz t, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, MeosType basetype, MeosType spantype); +extern TBox *tbox_get_value_time_tile(Datum value, TimestampTz t, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, meosType basetype, meosType spantype); extern Temporal **tnumber_value_time_split(const Temporal *temp, Datum size, const Interval *duration, Datum vorigin, TimestampTz torigin, Datum **value_bins, TimestampTz **time_bins, int *count); @@ -3274,16 +3237,12 @@ extern Temporal **tnumber_value_time_split(const Temporal *temp, Datum size, con //#include -//#include - //#include //#include //#include extern PJ_CONTEXT *proj_get_context(void); -/* extern GEOSContextHandle_t geos_get_context(void); (undefined type GEOSContextHandle_t) */ - extern Datum datum_geo_round(Datum value, Datum size); extern GSERIALIZED *point_round(const GSERIALIZED *gs, int maxdd); @@ -3292,7 +3251,7 @@ extern void stbox_set(bool hasx, bool hasz, bool geodetic, int32 srid, double xm extern void gbox_set_stbox(const GBOX *box, int32_t srid, STBox *result); extern bool geo_set_stbox(const GSERIALIZED *gs, STBox *box); extern void geoarr_set_stbox(const Datum *values, int count, STBox *box); -extern bool spatial_set_stbox(Datum d, MeosType basetype, STBox *box); +extern bool spatial_set_stbox(Datum d, meosType basetype, STBox *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); @@ -3335,18 +3294,17 @@ extern void tgeoinst_set_stbox(const TInstant *inst, STBox *box); extern void tspatialseq_set_stbox(const TSequence *seq, STBox *box); extern void tspatialseqset_set_stbox(const TSequenceSet *ss, STBox *box); -extern Temporal *tgeo_restrict_elevation(const Temporal *temp, const Span *s, bool atfunc); -extern Temporal *tgeo_restrict_geom(const Temporal *temp, const GSERIALIZED *gs, bool atfunc); +extern Temporal *tgeo_restrict_geom(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan, bool atfunc); extern Temporal *tgeo_restrict_stbox(const Temporal *temp, const STBox *box, bool border_inc, bool atfunc); -extern TInstant *tgeoinst_restrict_geom(const TInstant *inst, const GSERIALIZED *gs, bool atfunc); +extern TInstant *tgeoinst_restrict_geom(const TInstant *inst, const GSERIALIZED *gs, const Span *zspan, bool atfunc); extern TInstant *tgeoinst_restrict_stbox(const TInstant *inst, const STBox *box, bool border_inc, bool atfunc); -extern Temporal *tgeoseq_restrict_geom(const TSequence *seq, const GSERIALIZED *gs, bool atfunc); +extern Temporal *tgeoseq_restrict_geom(const TSequence *seq, const GSERIALIZED *gs, const Span *zspan, bool atfunc); extern Temporal *tgeoseq_restrict_stbox(const TSequence *seq, const STBox *box, bool border_inc, bool atfunc); -extern TSequenceSet *tgeoseqset_restrict_geom(const TSequenceSet *ss, const GSERIALIZED *gs, bool atfunc); +extern TSequenceSet *tgeoseqset_restrict_geom(const TSequenceSet *ss, const GSERIALIZED *gs, const Span *zspan, bool atfunc); extern TSequenceSet *tgeoseqset_restrict_stbox(const TSequenceSet *ss, const STBox *box, bool border_inc, bool atfunc); -extern int32_t spatial_srid(Datum d, MeosType basetype); -extern bool spatial_set_srid(Datum d, MeosType basetype, int32_t srid); +extern int32_t spatial_srid(Datum d, meosType basetype); +extern bool spatial_set_srid(Datum d, meosType basetype, int32_t srid); extern int tspatialinst_srid(const TInstant *inst); extern TSequenceSet *tpointseq_azimuth(const TSequence *seq); extern TSequence *tpointseq_cumulative_length(const TSequence *seq, double prevlength); From cef2a05396fa547dfc3fb2ffc9e339fc5606a354 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 14 May 2026 17:12:23 +0200 Subject: [PATCH 09/11] Add Datum helpers and detect int *count outputs These two gaps were keeping PyMEOS PR #72 (the 1.3 bump) at ~195 failures. With them in place the test count is 4472 passed / 10 failed; the remaining 10 are pre-existing test fixture issues unrelated to the bump. The is_output_parameter heuristic for trailing int *count was comparing parameter.ptype against a literal *' suffix, which never matched once cffi formatting moved the closing quote inside the Annotated[...] string. Switched the check to compare the raw ctype so tbool_values / tfloat_values / tint_values / tgeo_values etc. now return (array, count) tuples instead of forcing count as an input. Added float_to_datum / int_to_datum Python-side helpers using the cffi reinterpret-cast pattern (no need for libmeos to export Float8GetDatum), and four typed wrappers (tbox_expand_float / tbox_expand_int / tbox_shift_scale_float / tbox_shift_scale_int) that delegate to tbox_expand_value / tbox_shift_scale_value. MEOS 1.3 already exposed the Datum-shaped functions; these helpers restore the typed call shape that pre-1.3 PyMEOS callers depend on. --- builder/build_pymeos_functions.py | 4 +- builder/templates/functions.py | 43 + pymeos_cffi/__init__.py | 4751 ++++----- pymeos_cffi/functions.py | 15832 ++++++++++++---------------- 4 files changed, 8913 insertions(+), 11717 deletions(-) diff --git a/builder/build_pymeos_functions.py b/builder/build_pymeos_functions.py index cf30396..e1d109a 100644 --- a/builder/build_pymeos_functions.py +++ b/builder/build_pymeos_functions.py @@ -197,7 +197,9 @@ def is_result_parameter(function: str, parameter: Parameter) -> bool: def is_output_parameter(function: str, parameter: Parameter) -> bool: if parameter.name.endswith("_out"): return True - if parameter.name == "count" and parameter.ptype.endswith("*'"): + # ``int *count`` is the canonical trailing-output pattern that returns + # an array's length; auto-detect it on name + raw ctype. + if parameter.name == "count" and parameter.ctype == "int *": return True return (function, parameter.name) in output_parameters diff --git a/builder/templates/functions.py b/builder/templates/functions.py index dcb2e73..072f49c 100644 --- a/builder/templates/functions.py +++ b/builder/templates/functions.py @@ -132,6 +132,49 @@ def as_tsequenceset(temporal: Annotated[_ffi.CData, "Temporal *"]) -> Annotated[ return _ffi.cast("TSequenceSet *", temporal) +def float_to_datum(value: float) -> Annotated[_ffi.CData, "Datum"]: + # PostgreSQL's Float8GetDatum reinterprets the 8-byte double as a Datum. + buf = _ffi.new("double[1]", [value]) + return _ffi.cast("Datum *", buf)[0] + + +def int_to_datum(value: int) -> Annotated[_ffi.CData, "Datum"]: + # Int32GetDatum / Int64GetDatum widen the integer to Datum (uintptr_t). + return _ffi.cast("Datum", value) + + +def tbox_expand_float(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_expand_value(box, float_to_datum(d), _lib.T_FLOAT8) + + +def tbox_expand_int(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_expand_value(box, int_to_datum(i), _lib.T_INT4) + + +def tbox_shift_scale_float( + box: Annotated[_ffi.CData, "const TBox *"], + shift: float, + width: float, + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_shift_scale_value( + box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth + ) + + +def tbox_shift_scale_int( + box: Annotated[_ffi.CData, "const TBox *"], + shift: int, + width: int, + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_shift_scale_value( + box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth + ) + + # ----------------------------------------------------------------------------- # ----------------------End of manually-defined functions---------------------- # ----------------------------------------------------------------------------- diff --git a/pymeos_cffi/__init__.py b/pymeos_cffi/__init__.py index 2faed48..10bcc8e 100644 --- a/pymeos_cffi/__init__.py +++ b/pymeos_cffi/__init__.py @@ -2,7 +2,7 @@ from .errors import * from .functions import * -__version__ = "1.3.0a2" +__version__ = "1.3.0a1" __all__ = [ # Exceptions "MeosException", @@ -34,2375 +34,2382 @@ "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", - "date_in", - "date_out", - "interval_cmp", - "interval_in", - "interval_out", - "time_in", - "time_out", - "timestamp_in", - "timestamp_out", - "timestamptz_in", - "timestamptz_out", - "rtree_create_intspan", - "rtree_create_bigintspan", - "rtree_create_floatspan", - "rtree_create_datespan", - "rtree_create_tstzspan", - "rtree_create_tbox", - "rtree_create_stbox", - "rtree_free", - "rtree_insert", - "rtree_search", - "meos_errno", - "meos_errno_set", - "meos_errno_restore", - "meos_errno_reset", - "meos_finalize_projsrs", - "meos_finalize_ways", - "meos_set_datestyle", - "meos_set_intervalstyle", - "meos_get_datestyle", - "meos_get_intervalstyle", - "meos_set_spatial_ref_sys_csv", - "meos_initialize", - "meos_finalize", - "add_date_int", - "add_interval_interval", - "add_timestamptz_interval", - "bool_in", - "bool_out", - "cstring2text", - "date_to_timestamp", - "date_to_timestamptz", - "float_exp", - "float_ln", - "float_log10", - "float8_out", - "float_round", - "int32_cmp", - "int64_cmp", - "interval_make", - "minus_date_date", - "minus_date_int", - "minus_timestamptz_interval", - "minus_timestamptz_timestamptz", - "mul_interval_double", - "pg_date_in", - "pg_date_out", - "pg_interval_cmp", - "pg_interval_in", - "pg_interval_out", - "pg_timestamp_in", - "pg_timestamp_out", - "pg_timestamptz_in", - "pg_timestamptz_out", - "text2cstring", - "text_cmp", - "text_copy", - "text_in", - "text_initcap", - "text_lower", - "text_out", - "text_upper", - "textcat_text_text", - "timestamptz_shift", - "timestamp_to_date", - "timestamptz_to_date", - "bigintset_in", - "bigintset_out", - "bigintspan_expand", - "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_expand", - "floatspan_in", - "floatspan_out", - "floatspanset_in", - "floatspanset_out", - "intset_in", - "intset_out", - "intspan_expand", - "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", - "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", - "int_to_set", - "int_to_span", - "int_to_spanset", - "intset_to_floatset", - "intspan_to_floatspan", - "intspanset_to_floatspanset", - "set_to_span", - "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", - "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", - "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_spanarr", - "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_timestamps", - "tstzspanset_timestamptz_n", - "tstzspanset_upper", - "bigintset_shift_scale", - "bigintspan_shift_scale", - "bigintspanset_shift_scale", - "dateset_shift_scale", - "datespan_shift_scale", - "datespanset_shift_scale", - "floatset_ceil", - "floatset_degrees", - "floatset_floor", - "floatset_radians", - "floatset_shift_scale", - "floatspan_ceil", - "floatspan_degrees", - "floatspan_floor", - "floatspan_radians", - "floatspan_round", - "floatspan_shift_scale", - "floatspanset_ceil", - "floatspanset_floor", - "floatspanset_degrees", - "floatspanset_radians", - "floatspanset_round", - "floatspanset_shift_scale", - "intset_shift_scale", - "intspan_shift_scale", - "intspanset_shift_scale", - "tstzspan_expand", - "set_round", - "textcat_text_textset", - "textcat_textset_text", - "textset_initcap", - "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", - "set_spans", - "set_split_each_n_spans", - "set_split_n_spans", - "spanset_spans", - "spanset_split_each_n_spans", - "spanset_split_n_spans", - "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_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_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_int_set", - "intersection_set_bigint", - "intersection_set_date", - "intersection_set_float", - "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_int_set", - "minus_int_span", - "minus_int_spanset", - "minus_set_bigint", - "minus_set_date", - "minus_set_float", - "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_int_set", - "union_int_span", - "union_int_spanset", - "union_set_bigint", - "union_set_date", - "union_set_float", - "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", - "bigint_get_bin", - "bigintspan_bins", - "bigintspanset_bins", - "date_get_bin", - "datespan_bins", - "datespanset_bins", - "float_get_bin", - "floatspan_bins", - "floatspanset_bins", - "int_get_bin", - "intspan_bins", - "intspanset_bins", - "timestamptz_get_bin", - "tstzspan_bins", - "tstzspanset_bins", - "tbox_as_hexwkb", - "tbox_as_wkb", - "tbox_from_hexwkb", - "tbox_from_wkb", - "tbox_in", - "tbox_out", - "float_timestamptz_to_tbox", - "float_tstzspan_to_tbox", - "int_timestamptz_to_tbox", - "int_tstzspan_to_tbox", - "numspan_tstzspan_to_tbox", - "numspan_timestamptz_to_tbox", - "tbox_copy", - "tbox_make", - "float_to_tbox", - "int_to_tbox", - "set_to_tbox", - "span_to_tbox", - "spanset_to_tbox", - "tbox_to_intspan", - "tbox_to_floatspan", - "tbox_to_tstzspan", - "timestamptz_to_tbox", - "tbox_hash", - "tbox_hash_extended", - "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", - "tbox_expand_time", - "tbox_round", - "tbox_shift_scale_time", - "tfloatbox_expand", - "tfloatbox_shift_scale", - "tintbox_expand", - "tintbox_shift_scale", - "union_tbox_tbox", - "intersection_tbox_tbox", - "adjacent_tbox_tbox", - "contained_tbox_tbox", - "contains_tbox_tbox", - "overlaps_tbox_tbox", - "same_tbox_tbox", - "after_tbox_tbox", - "before_tbox_tbox", - "left_tbox_tbox", - "overafter_tbox_tbox", - "overbefore_tbox_tbox", - "overleft_tbox_tbox", - "overright_tbox_tbox", - "right_tbox_tbox", - "tbox_cmp", - "tbox_eq", - "tbox_ge", - "tbox_gt", - "tbox_le", - "tbox_lt", - "tbox_ne", - "tbool_from_mfjson", - "tbool_in", - "tbool_out", - "temporal_as_hexwkb", - "temporal_as_mfjson", - "temporal_as_wkb", - "temporal_from_hexwkb", - "temporal_from_wkb", - "tfloat_from_mfjson", - "tfloat_in", - "tfloat_out", - "tint_from_mfjson", - "tint_in", - "tint_out", - "ttext_from_mfjson", - "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_tstzset", - "tfloatseq_from_base_tstzspan", - "tfloatseqset_from_base_tstzspanset", - "tint_from_base_temp", - "tintinst_make", - "tintseq_from_base_tstzset", - "tintseq_from_base_tstzspan", - "tintseqset_from_base_tstzspanset", - "tsequence_make", - "tsequenceset_make", - "tsequenceset_make_gaps", - "ttext_from_base_temp", - "ttextinst_make", - "ttextseq_from_base_tstzset", - "ttextseq_from_base_tstzspan", - "ttextseqset_from_base_tstzspanset", - "tbool_to_tint", - "temporal_to_tstzspan", - "tfloat_to_tint", - "tint_to_tfloat", - "tnumber_to_span", - "tnumber_to_tbox", - "tbool_end_value", - "tbool_start_value", - "tbool_value_at_timestamptz", - "tbool_value_n", - "tbool_values", - "temporal_duration", - "temporal_end_instant", - "temporal_end_sequence", - "temporal_end_timestamptz", - "temporal_hash", - "temporal_instant_n", - "temporal_instants", - "temporal_interp", - "temporal_lower_inc", - "temporal_max_instant", - "temporal_min_instant", - "temporal_num_instants", - "temporal_num_sequences", - "temporal_num_timestamps", - "temporal_segm_duration", - "temporal_segments", - "temporal_sequence_n", - "temporal_sequences", - "temporal_start_instant", - "temporal_start_sequence", - "temporal_start_timestamptz", - "temporal_stops", - "temporal_subtype", - "temporal_time", - "temporal_timestamps", - "temporal_timestamptz_n", - "temporal_upper_inc", - "tfloat_end_value", - "tfloat_min_value", - "tfloat_max_value", - "tfloat_start_value", - "tfloat_value_at_timestamptz", - "tfloat_value_n", - "tfloat_values", - "tint_end_value", - "tint_max_value", - "tint_min_value", - "tint_start_value", - "tint_value_at_timestamptz", - "tint_value_n", - "tint_values", - "tnumber_avg_value", - "tnumber_integral", - "tnumber_twavg", - "tnumber_valuespans", - "ttext_end_value", - "ttext_max_value", - "ttext_min_value", - "ttext_start_value", - "ttext_value_at_timestamptz", - "ttext_value_n", - "ttext_values", - "float_degrees", - "temparr_round", - "temporal_round", - "temporal_scale_time", - "temporal_set_interp", - "temporal_shift_scale_time", - "temporal_shift_time", - "temporal_to_tinstant", - "temporal_to_tsequence", - "temporal_to_tsequenceset", - "tfloat_ceil", - "tfloat_degrees", - "tfloat_floor", - "tfloat_radians", - "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_timestamptz", - "temporal_delete_tstzset", - "temporal_delete_tstzspan", - "temporal_delete_tstzspanset", - "temporal_insert", - "temporal_merge", - "temporal_merge_array", - "temporal_update", - "tbool_at_value", - "tbool_minus_value", - "temporal_after_timestamptz", - "temporal_at_max", - "temporal_at_min", - "temporal_at_timestamptz", - "temporal_at_tstzset", - "temporal_at_tstzspan", - "temporal_at_tstzspanset", - "temporal_at_values", - "temporal_before_timestamptz", - "temporal_minus_max", - "temporal_minus_min", - "temporal_minus_timestamptz", - "temporal_minus_tstzset", - "temporal_minus_tstzspan", - "temporal_minus_tstzspanset", - "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", - "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_tbool_bool", - "always_eq_temporal_temporal", - "always_eq_text_ttext", - "always_eq_tfloat_float", - "always_eq_tint_int", - "always_eq_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", - "always_ne_bool_tbool", - "always_ne_float_tfloat", - "always_ne_int_tint", - "always_ne_tbool_bool", - "always_ne_temporal_temporal", - "always_ne_text_ttext", - "always_ne_tfloat_float", - "always_ne_tint_int", - "always_ne_ttext_text", - "ever_eq_bool_tbool", - "ever_eq_float_tfloat", - "ever_eq_int_tint", - "ever_eq_tbool_bool", - "ever_eq_temporal_temporal", - "ever_eq_text_ttext", - "ever_eq_tfloat_float", - "ever_eq_tint_int", - "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_tbool_bool", - "ever_ne_temporal_temporal", - "ever_ne_text_ttext", - "ever_ne_tfloat_float", - "ever_ne_tint_int", - "ever_ne_ttext_text", - "teq_bool_tbool", - "teq_float_tfloat", - "teq_int_tint", - "teq_tbool_bool", - "teq_temporal_temporal", - "teq_text_ttext", - "teq_tfloat_float", - "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_tbool_bool", - "tne_temporal_temporal", - "tne_text_ttext", - "tne_tfloat_float", - "tne_tint_int", - "tne_ttext_text", - "temporal_spans", - "temporal_split_each_n_spans", - "temporal_split_n_spans", - "tnumber_split_each_n_tboxes", - "tnumber_split_n_tboxes", - "tnumber_tboxes", - "adjacent_numspan_tnumber", - "adjacent_tbox_tnumber", - "adjacent_temporal_temporal", - "adjacent_temporal_tstzspan", - "adjacent_tnumber_numspan", - "adjacent_tnumber_tbox", - "adjacent_tnumber_tnumber", - "adjacent_tstzspan_temporal", - "contained_numspan_tnumber", - "contained_tbox_tnumber", - "contained_temporal_temporal", - "contained_temporal_tstzspan", - "contained_tnumber_numspan", - "contained_tnumber_tbox", - "contained_tnumber_tnumber", - "contained_tstzspan_temporal", - "contains_numspan_tnumber", - "contains_tbox_tnumber", - "contains_temporal_tstzspan", - "contains_temporal_temporal", - "contains_tnumber_numspan", - "contains_tnumber_tbox", - "contains_tnumber_tnumber", - "contains_tstzspan_temporal", - "overlaps_numspan_tnumber", - "overlaps_tbox_tnumber", - "overlaps_temporal_temporal", - "overlaps_temporal_tstzspan", - "overlaps_tnumber_numspan", - "overlaps_tnumber_tbox", - "overlaps_tnumber_tnumber", - "overlaps_tstzspan_temporal", - "same_numspan_tnumber", - "same_tbox_tnumber", - "same_temporal_temporal", - "same_temporal_tstzspan", - "same_tnumber_numspan", - "same_tnumber_tbox", - "same_tnumber_tnumber", - "same_tstzspan_temporal", - "after_tbox_tnumber", - "after_temporal_tstzspan", - "after_temporal_temporal", - "after_tnumber_tbox", - "after_tnumber_tnumber", - "after_tstzspan_temporal", - "before_tbox_tnumber", - "before_temporal_tstzspan", - "before_temporal_temporal", - "before_tnumber_tbox", - "before_tnumber_tnumber", - "before_tstzspan_temporal", - "left_tbox_tnumber", - "left_numspan_tnumber", - "left_tnumber_numspan", - "left_tnumber_tbox", - "left_tnumber_tnumber", - "overafter_tbox_tnumber", - "overafter_temporal_tstzspan", - "overafter_temporal_temporal", - "overafter_tnumber_tbox", - "overafter_tnumber_tnumber", - "overafter_tstzspan_temporal", - "overbefore_tbox_tnumber", - "overbefore_temporal_tstzspan", - "overbefore_temporal_temporal", - "overbefore_tnumber_tbox", - "overbefore_tnumber_tnumber", - "overbefore_tstzspan_temporal", - "overleft_numspan_tnumber", - "overleft_tbox_tnumber", - "overleft_tnumber_numspan", - "overleft_tnumber_tbox", - "overleft_tnumber_tnumber", - "overright_numspan_tnumber", - "overright_tbox_tnumber", - "overright_tnumber_numspan", - "overright_tnumber_tbox", - "overright_tnumber_tnumber", - "right_numspan_tnumber", - "right_tbox_tnumber", - "right_tnumber_numspan", - "right_tnumber_tbox", - "right_tnumber_tnumber", - "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", - "temporal_derivative", - "tfloat_exp", - "tfloat_ln", - "tfloat_log10", - "tnumber_abs", - "tnumber_trend", - "float_angular_difference", - "tnumber_angular_difference", - "tnumber_delta_value", - "textcat_text_ttext", - "textcat_ttext_text", - "textcat_ttext_ttext", - "ttext_initcap", - "ttext_upper", - "ttext_lower", - "tdistance_tfloat_float", - "tdistance_tint_int", - "tdistance_tnumber_tnumber", - "nad_tboxfloat_tboxfloat", - "nad_tboxint_tboxint", - "nad_tfloat_float", - "nad_tfloat_tfloat", - "nad_tfloat_tbox", - "nad_tint_int", - "nad_tint_tbox", - "nad_tint_tint", - "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", - "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", - "temporal_time_bins", - "temporal_time_split", - "tfloat_time_boxes", - "tfloat_value_bins", - "tfloat_value_boxes", - "tfloat_value_split", - "tfloat_value_time_boxes", - "tfloat_value_time_split", - "tfloatbox_time_tiles", - "tfloatbox_value_tiles", - "tfloatbox_value_time_tiles", - "tint_time_boxes", - "tint_value_bins", - "tint_value_boxes", - "tint_value_split", - "tint_value_time_boxes", - "tint_value_time_split", - "tintbox_time_tiles", - "tintbox_value_tiles", - "tintbox_value_time_tiles", - "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", - "tnumber_basetype", - "geo_basetype", - "time_type", - "set_type", - "numset_type", - "ensure_numset_type", - "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", - "type_span_bbox", - "span_tbox_type", - "ensure_span_tbox_type", - "numspan_basetype", - "numspan_type", - "ensure_numspan_type", - "timespan_basetype", - "timespan_type", - "spanset_type", - "timespanset_type", - "ensure_timespanset_type", - "temporal_type", - "temptype_continuous", - "basetype_byvalue", - "basetype_varlength", - "basetype_length", - "talpha_type", - "tnumber_type", - "ensure_tnumber_type", - "ensure_tnumber_basetype", - "tnumber_spantype", - "spatial_basetype", - "tspatial_type", - "ensure_tspatial_type", - "tpoint_type", - "ensure_tpoint_type", - "tgeo_type", - "ensure_tgeo_type", - "tgeo_type_all", - "ensure_tgeo_type_all", - "tgeometry_type", - "ensure_tgeometry_type", - "tgeodetic_type", - "ensure_tgeodetic_type", - "ensure_tnumber_tpoint_type", - "geo_as_ewkb", - "geo_as_ewkt", - "geo_as_geojson", - "geo_as_hexewkb", - "geo_as_text", - "geo_from_ewkb", - "geo_from_geojson", - "geo_from_text", - "geo_out", - "geog_from_hexewkb", - "geog_in", - "geom_from_hexewkb", - "geom_in", - "box3d_make", - "box3d_out", - "gbox_make", - "gbox_out", - "geo_copy", - "geogpoint_make2d", - "geogpoint_make3dz", - "geompoint_make2d", - "geompoint_make3dz", - "geom_to_geog", - "geog_to_geom", - "geo_is_empty", - "geo_is_unitary", - "geo_typename", - "geog_area", - "geog_centroid", - "geog_length", - "geog_perimeter", - "geom_azimuth", - "geom_length", - "geom_perimeter", - "line_numpoints", - "line_point_n", - "geo_reverse", - "geo_round", - "geo_set_srid", - "geo_srid", - "geo_transform", - "geo_transform_pipeline", - "geo_collect_garray", - "geo_makeline_garray", - "geo_num_points", - "geo_num_geos", - "geo_geo_n", - "geo_pointarr", - "geo_points", - "geom_array_union", - "geom_boundary", - "geom_buffer", - "geom_centroid", - "geom_convex_hull", - "geom_difference2d", - "geom_intersection2d", - "geom_intersection2d_coll", - "geom_min_bounding_radius", - "geom_shortestline2d", - "geom_shortestline3d", - "geom_unary_union", - "line_interpolate_point", - "line_locate_point", - "line_substring", - "geog_dwithin", - "geog_intersects", - "geom_contains", - "geom_covers", - "geom_disjoint2d", - "geom_dwithin2d", - "geom_dwithin3d", - "geom_intersects2d", - "geom_intersects3d", - "geom_relate_pattern", - "geom_touches", - "geo_stboxes", - "geo_split_each_n_stboxes", - "geo_split_n_stboxes", - "geog_distance", - "geom_distance2d", - "geom_distance3d", - "geo_equals", - "geo_same", - "geogset_in", - "geomset_in", - "spatialset_as_text", - "spatialset_as_ewkt", - "geoset_make", - "geo_to_set", - "geoset_end_value", - "geoset_start_value", - "geoset_value_n", - "geoset_values", - "contained_geo_set", - "contains_set_geo", - "geo_union_transfn", - "intersection_geo_set", - "intersection_set_geo", - "minus_geo_set", - "minus_set_geo", - "union_geo_set", - "union_set_geo", - "spatialset_set_srid", - "spatialset_srid", - "spatialset_transform", - "spatialset_transform_pipeline", - "stbox_as_hexwkb", - "stbox_as_wkb", - "stbox_from_hexwkb", - "stbox_from_wkb", - "stbox_in", - "stbox_out", - "geo_timestamptz_to_stbox", - "geo_tstzspan_to_stbox", - "stbox_copy", - "stbox_make", - "geo_to_stbox", - "spatialset_to_stbox", - "stbox_to_box3d", - "stbox_to_gbox", - "stbox_to_geo", - "stbox_to_tstzspan", - "timestamptz_to_stbox", - "tstzset_to_stbox", - "tstzspan_to_stbox", - "tstzspanset_to_stbox", - "stbox_area", - "stbox_hash", - "stbox_hash_extended", - "stbox_hast", - "stbox_hasx", - "stbox_hasz", - "stbox_isgeodetic", - "stbox_perimeter", - "stbox_tmax", - "stbox_tmax_inc", - "stbox_tmin", - "stbox_tmin_inc", - "stbox_volume", - "stbox_xmax", - "stbox_xmin", - "stbox_ymax", - "stbox_ymin", - "stbox_zmax", - "stbox_zmin", - "stbox_expand_space", - "stbox_expand_time", - "stbox_get_space", - "stbox_quad_split", - "stbox_round", - "stbox_shift_scale_time", - "stboxarr_round", - "stbox_set_srid", - "stbox_srid", - "stbox_transform", - "stbox_transform_pipeline", - "adjacent_stbox_stbox", - "contained_stbox_stbox", - "contains_stbox_stbox", - "overlaps_stbox_stbox", - "same_stbox_stbox", - "above_stbox_stbox", - "after_stbox_stbox", - "back_stbox_stbox", - "before_stbox_stbox", - "below_stbox_stbox", - "front_stbox_stbox", - "left_stbox_stbox", - "overabove_stbox_stbox", - "overafter_stbox_stbox", - "overback_stbox_stbox", - "overbefore_stbox_stbox", - "overbelow_stbox_stbox", - "overfront_stbox_stbox", - "overleft_stbox_stbox", - "overright_stbox_stbox", - "right_stbox_stbox", - "union_stbox_stbox", - "intersection_stbox_stbox", - "stbox_cmp", - "stbox_eq", - "stbox_ge", - "stbox_gt", - "stbox_le", - "stbox_lt", - "stbox_ne", - "tgeogpoint_from_mfjson", - "tgeogpoint_in", - "tgeography_from_mfjson", - "tgeography_in", - "tgeometry_from_mfjson", - "tgeometry_in", - "tgeompoint_from_mfjson", - "tgeompoint_in", - "tspatial_as_ewkt", - "tspatial_as_text", - "tspatial_out", - "tgeo_from_base_temp", - "tgeoinst_make", - "tgeoseq_from_base_tstzset", - "tgeoseq_from_base_tstzspan", - "tgeoseqset_from_base_tstzspanset", - "tpoint_from_base_temp", - "tpointinst_make", - "tpointseq_from_base_tstzset", - "tpointseq_from_base_tstzspan", - "tpointseq_make_coords", - "tpointseqset_from_base_tstzspanset", - "box3d_to_stbox", - "gbox_to_stbox", - "geomeas_to_tpoint", - "tgeogpoint_to_tgeography", - "tgeography_to_tgeogpoint", - "tgeography_to_tgeometry", - "tgeometry_to_tgeography", - "tgeometry_to_tgeompoint", - "tgeompoint_to_tgeometry", - "tpoint_as_mvtgeom", - "tpoint_tfloat_to_geomeas", - "tspatial_to_stbox", - "bearing_point_point", - "bearing_tpoint_point", - "bearing_tpoint_tpoint", - "tgeo_centroid", - "tgeo_convex_hull", - "tgeo_end_value", - "tgeo_start_value", - "tgeo_traversed_area", - "tgeo_value_at_timestamptz", - "tgeo_value_n", - "tgeo_values", - "tpoint_angular_difference", - "tpoint_azimuth", - "tpoint_cumulative_length", - "tpoint_direction", - "tpoint_get_x", - "tpoint_get_y", - "tpoint_get_z", - "tpoint_is_simple", - "tpoint_length", - "tpoint_speed", - "tpoint_trajectory", - "tpoint_twcentroid", - "tgeo_affine", - "tgeo_scale", - "tpoint_make_simple", - "tspatial_srid", - "tspatial_set_srid", - "tspatial_transform", - "tspatial_transform_pipeline", - "tgeo_at_geom", - "tgeo_at_stbox", - "tgeo_at_value", - "tgeo_minus_geom", - "tgeo_minus_stbox", - "tgeo_minus_value", - "tpoint_at_geom", - "tpoint_at_value", - "tpoint_minus_geom", - "tpoint_minus_value", - "always_eq_geo_tgeo", - "always_eq_tgeo_geo", - "always_eq_tgeo_tgeo", - "always_ne_geo_tgeo", - "always_ne_tgeo_geo", - "always_ne_tgeo_tgeo", - "ever_eq_geo_tgeo", - "ever_eq_tgeo_geo", - "ever_eq_tgeo_tgeo", - "ever_ne_geo_tgeo", - "ever_ne_tgeo_geo", - "ever_ne_tgeo_tgeo", - "teq_geo_tgeo", - "teq_tgeo_geo", - "tne_geo_tgeo", - "tne_tgeo_geo", - "tgeo_stboxes", - "tgeo_space_boxes", - "tgeo_space_time_boxes", - "tgeo_split_each_n_stboxes", - "tgeo_split_n_stboxes", - "adjacent_stbox_tspatial", - "adjacent_tspatial_stbox", - "adjacent_tspatial_tspatial", - "contained_stbox_tspatial", - "contained_tspatial_stbox", - "contained_tspatial_tspatial", - "contains_stbox_tspatial", - "contains_tspatial_stbox", - "contains_tspatial_tspatial", - "overlaps_stbox_tspatial", - "overlaps_tspatial_stbox", - "overlaps_tspatial_tspatial", - "same_stbox_tspatial", - "same_tspatial_stbox", - "same_tspatial_tspatial", - "above_stbox_tspatial", - "above_tspatial_stbox", - "above_tspatial_tspatial", - "after_stbox_tspatial", - "after_tspatial_stbox", - "after_tspatial_tspatial", - "back_stbox_tspatial", - "back_tspatial_stbox", - "back_tspatial_tspatial", - "before_stbox_tspatial", - "before_tspatial_stbox", - "before_tspatial_tspatial", - "below_stbox_tspatial", - "below_tspatial_stbox", - "below_tspatial_tspatial", - "front_stbox_tspatial", - "front_tspatial_stbox", - "front_tspatial_tspatial", - "left_stbox_tspatial", - "left_tspatial_stbox", - "left_tspatial_tspatial", - "overabove_stbox_tspatial", - "overabove_tspatial_stbox", - "overabove_tspatial_tspatial", - "overafter_stbox_tspatial", - "overafter_tspatial_stbox", - "overafter_tspatial_tspatial", - "overback_stbox_tspatial", - "overback_tspatial_stbox", - "overback_tspatial_tspatial", - "overbefore_stbox_tspatial", - "overbefore_tspatial_stbox", - "overbefore_tspatial_tspatial", - "overbelow_stbox_tspatial", - "overbelow_tspatial_stbox", - "overbelow_tspatial_tspatial", - "overfront_stbox_tspatial", - "overfront_tspatial_stbox", - "overfront_tspatial_tspatial", - "overleft_stbox_tspatial", - "overleft_tspatial_stbox", - "overleft_tspatial_tspatial", - "overright_stbox_tspatial", - "overright_tspatial_stbox", - "overright_tspatial_tspatial", - "right_stbox_tspatial", - "right_tspatial_stbox", - "right_tspatial_tspatial", - "acontains_geo_tgeo", - "acontains_tgeo_geo", - "acontains_tgeo_tgeo", - "adisjoint_tgeo_geo", - "adisjoint_tgeo_tgeo", - "adwithin_tgeo_geo", - "adwithin_tgeo_tgeo", - "aintersects_tgeo_geo", - "aintersects_tgeo_tgeo", - "atouches_tgeo_geo", - "atouches_tgeo_tgeo", - "atouches_tpoint_geo", - "econtains_geo_tgeo", - "econtains_tgeo_geo", - "econtains_tgeo_tgeo", - "ecovers_geo_tgeo", - "ecovers_tgeo_geo", - "ecovers_tgeo_tgeo", - "edisjoint_tgeo_geo", - "edisjoint_tgeo_tgeo", - "edwithin_tgeo_geo", - "edwithin_tgeo_tgeo", - "eintersects_tgeo_geo", - "eintersects_tgeo_tgeo", - "etouches_tgeo_geo", - "etouches_tgeo_tgeo", - "etouches_tpoint_geo", - "tcontains_geo_tgeo", - "tcontains_tgeo_geo", - "tcontains_tgeo_tgeo", - "tcovers_geo_tgeo", - "tcovers_tgeo_geo", - "tcovers_tgeo_tgeo", - "tdisjoint_geo_tgeo", - "tdisjoint_tgeo_geo", - "tdisjoint_tgeo_tgeo", - "tdwithin_geo_tgeo", - "tdwithin_tgeo_geo", - "tdwithin_tgeo_tgeo", - "tintersects_geo_tgeo", - "tintersects_tgeo_geo", - "tintersects_tgeo_tgeo", - "ttouches_geo_tgeo", - "ttouches_tgeo_geo", - "ttouches_tgeo_tgeo", - "tdistance_tgeo_geo", - "tdistance_tgeo_tgeo", - "nad_stbox_geo", - "nad_stbox_stbox", - "nad_tgeo_geo", - "nad_tgeo_stbox", - "nad_tgeo_tgeo", - "nai_tgeo_geo", - "nai_tgeo_tgeo", - "shortestline_tgeo_geo", - "shortestline_tgeo_tgeo", - "tpoint_tcentroid_finalfn", - "tpoint_tcentroid_transfn", - "tspatial_extent_transfn", - "stbox_get_space_tile", - "stbox_get_space_time_tile", - "stbox_get_time_tile", - "stbox_space_tiles", - "stbox_space_time_tiles", - "stbox_time_tiles", - "tgeo_space_split", - "tgeo_space_time_split", - "geo_cluster_kmeans", - "geo_cluster_dbscan", - "geo_cluster_intersecting", - "geo_cluster_within", - "gsl_get_generation_rng", - "gsl_get_aggregation_rng", - "datum_ceil", - "datum_degrees", - "datum_float_round", - "datum_floor", - "datum_hash", - "datum_hash_extended", - "datum_radians", - "floatspan_round_set", - "set_in", - "set_out", - "span_in", - "span_out", - "spanset_in", - "spanset_out", - "set_make", - "set_make_exp", - "set_make_free", - "span_make", - "span_set", - "spanset_make_exp", - "spanset_make_free", - "set_span", - "set_spanset", - "value_set_span", - "value_set", - "value_span", - "value_spanset", - "numspan_width", - "numspanset_width", - "set_end_value", - "set_mem_size", - "set_set_subspan", - "set_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_set_intspan", - "intspan_set_floatspan", - "numset_shift_scale", - "numspan_expand", - "numspan_shift_scale", - "numspanset_shift_scale", - "set_compact", - "span_expand", - "spanset_compact", - "tbox_expand_value", - "textcat_textset_text_common", - "tstzspan_set_datespan", - "adjacent_span_value", - "adjacent_spanset_value", - "adjacent_value_spanset", - "contained_value_set", - "contained_value_span", - "contained_value_spanset", - "contains_set_value", - "contains_span_value", - "contains_spanset_value", - "ovadj_span_span", - "left_set_value", - "left_span_value", - "left_spanset_value", - "left_value_set", - "left_value_span", - "left_value_spanset", - "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", - "right_value_set", - "right_set_value", - "right_value_span", - "right_value_spanset", - "right_span_value", - "right_spanset_value", - "bbox_type", - "bbox_get_size", - "bbox_max_dims", - "temporal_bbox_eq", - "temporal_bbox_cmp", - "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", - "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", - "tbox_set", - "float_set_tbox", - "int_set_tbox", - "number_set_tbox", - "number_tbox", - "numset_set_tbox", - "numspan_set_tbox", - "timestamptz_set_tbox", - "tstzset_set_tbox", - "tstzspan_set_tbox", - "tbox_shift_scale_value", - "tbox_expand", - "inter_tbox_tbox", - "tboolinst_in", - "tboolseq_in", - "tboolseqset_in", - "temporal_in", - "temporal_out", - "temparr_out", - "tfloatinst_in", - "tfloatseq_in", - "tfloatseqset_in", - "tinstant_in", - "tinstant_out", - "tintinst_in", - "tintseq_in", - "tintseqset_in", - "tsequence_in", - "tsequence_out", - "tsequenceset_in", - "tsequenceset_out", - "ttextinst_in", - "ttextseq_in", - "ttextseqset_in", - "temporal_from_mfjson", - "temporal_from_base_temp", - "tinstant_copy", - "tinstant_make", - "tinstant_make_free", - "tsequence_copy", - "tsequence_from_base_temp", - "tsequence_from_base_tstzset", - "tsequence_from_base_tstzspan", - "tsequence_make_exp", - "tsequence_make_free", - "tsequenceset_copy", - "tseqsetarr_to_tseqset", - "tsequenceset_from_base_temp", - "tsequenceset_from_base_tstzspanset", - "tsequenceset_make_exp", - "tsequenceset_make_free", - "temporal_set_tstzspan", - "tinstant_set_tstzspan", - "tnumber_set_tbox", - "tnumberinst_set_tbox", - "tnumberseq_set_tbox", - "tnumberseqset_set_tbox", - "tsequence_set_tstzspan", - "tsequenceset_set_tstzspan", - "temporal_end_inst", - "temporal_end_value", - "temporal_inst_n", - "temporal_insts_p", - "temporal_max_inst_p", - "temporal_max_value", - "temporal_mem_size", - "temporal_min_inst_p", - "temporal_min_value", - "temporal_sequences_p", - "temporal_set_bbox", - "temporal_start_inst", - "temporal_start_value", - "temporal_values_p", - "temporal_value_n", - "temporal_values", - "tinstant_hash", - "tinstant_insts", - "tinstant_set_bbox", - "tinstant_time", - "tinstant_timestamps", - "tinstant_value_p", - "tinstant_value", - "tinstant_value_at_timestamptz", - "tinstant_values_p", - "tnumber_set_span", - "tnumberinst_valuespans", - "tnumberseq_avg_val", - "tnumberseq_valuespans", - "tnumberseqset_avg_val", - "tnumberseqset_valuespans", - "tsequence_duration", - "tsequence_end_timestamptz", - "tsequence_hash", - "tsequence_insts_p", - "tsequence_max_inst_p", - "tsequence_max_val", - "tsequence_min_inst_p", - "tsequence_min_val", - "tsequence_segments", - "tsequence_seqs", - "tsequence_start_timestamptz", - "tsequence_time", - "tsequence_timestamps", - "tsequence_value_at_timestamptz", - "tsequence_values_p", - "tsequenceset_duration", - "tsequenceset_end_timestamptz", - "tsequenceset_hash", - "tsequenceset_inst_n", - "tsequenceset_insts_p", - "tsequenceset_max_inst_p", - "tsequenceset_max_val", - "tsequenceset_min_inst_p", - "tsequenceset_min_val", - "tsequenceset_num_instants", - "tsequenceset_num_timestamps", - "tsequenceset_segments", - "tsequenceset_sequences_p", - "tsequenceset_start_timestamptz", - "tsequenceset_time", - "tsequenceset_timestamptz_n", - "tsequenceset_timestamps", - "tsequenceset_value_at_timestamptz", - "tsequenceset_value_n", - "tsequenceset_values_p", - "temporal_restart", - "temporal_tsequence", - "temporal_tsequenceset", - "tinstant_shift_time", - "tinstant_to_tsequence", - "tinstant_to_tsequence_free", - "tinstant_to_tsequenceset", - "tnumber_shift_scale_value", - "tnumberinst_shift_value", - "tnumberseq_shift_scale_value", - "tnumberseqset_shift_scale_value", - "tsequence_restart", - "tsequence_set_interp", - "tsequence_shift_scale_time", - "tsequence_subseq", - "tsequence_to_tinstant", - "tsequence_to_tsequenceset", - "tsequence_to_tsequenceset_free", - "tsequence_to_tsequenceset_interp", - "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", - "tcontseq_after_timestamptz", - "tcontseq_before_timestamptz", - "tcontseq_restrict_minmax", - "tdiscseq_after_timestamptz", - "tdiscseq_before_timestamptz", - "tdiscseq_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_after_timestamptz", - "tinstant_before_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", - "tsequence_at_timestamptz", - "tsequence_restrict_tstzspan", - "tsequence_restrict_tstzspanset", - "tsequenceset_after_timestamptz", - "tsequenceset_before_timestamptz", - "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_ne_base_temporal", - "always_ne_temporal_base", - "always_ge_base_temporal", - "always_ge_temporal_base", - "always_gt_base_temporal", - "always_gt_temporal_base", - "always_le_base_temporal", - "always_le_temporal_base", - "always_lt_base_temporal", - "always_lt_temporal_base", - "ever_eq_base_temporal", - "ever_eq_temporal_base", - "ever_ne_base_temporal", - "ever_ne_temporal_base", - "ever_ge_base_temporal", - "ever_ge_temporal_base", - "ever_gt_base_temporal", - "ever_gt_temporal_base", - "ever_le_base_temporal", - "ever_le_temporal_base", - "ever_lt_base_temporal", - "ever_lt_temporal_base", - "tnumberinst_abs", - "tnumberseq_abs", - "tnumberseq_angular_difference", - "tnumberseq_delta_value", - "tnumberseqset_abs", - "tnumberseqset_angular_difference", - "tnumberseqset_delta_value", - "tdistance_tnumber_number", - "nad_tbox_tbox", - "nad_tnumber_number", - "nad_tnumber_tbox", - "nad_tnumber_tnumber", - "tnumberseq_integral", - "tnumberseq_twavg", - "tnumberseqset_integral", - "tnumberseqset_twavg", - "temporal_compact", - "tsequence_compact", - "tsequenceset_compact", - "temporal_skiplist_make", - "skiplist_search", - "skiplist_free", - "skiplist_splice", - "temporal_skiplist_splice", - "skiplist_values", - "skiplist_keys_values", - "temporal_app_tinst_transfn", - "temporal_app_tseq_transfn", - "span_bins", - "spanset_bins", - "tnumber_value_bins", - "tnumber_value_time_boxes", - "tnumber_value_split", - "tbox_get_value_time_tile", - "tnumber_value_time_split", - "proj_get_context", - "datum_geo_round", - "point_round", - "stbox_set", - "gbox_set_stbox", - "geo_set_stbox", - "geoarr_set_stbox", - "spatial_set_stbox", - "spatialset_set_stbox", - "stbox_set_box3d", - "stbox_set_gbox", - "tstzset_set_stbox", - "tstzspan_set_stbox", - "tstzspanset_set_stbox", - "stbox_expand", - "inter_stbox_stbox", - "stbox_geo", - "tgeogpointinst_in", - "tgeogpointseq_in", - "tgeogpointseqset_in", - "tgeompointinst_in", - "tgeompointseq_in", - "tgeompointseqset_in", - "tgeographyinst_in", - "tgeographyseq_in", - "tgeographyseqset_in", - "tgeometryinst_in", - "tgeometryseq_in", - "tgeometryseqset_in", - "tspatial_set_stbox", - "tgeoinst_set_stbox", - "tspatialseq_set_stbox", - "tspatialseqset_set_stbox", - "tgeo_restrict_geom", - "tgeo_restrict_stbox", - "tgeoinst_restrict_geom", - "tgeoinst_restrict_stbox", - "tgeoseq_restrict_geom", - "tgeoseq_restrict_stbox", - "tgeoseqset_restrict_geom", - "tgeoseqset_restrict_stbox", - "spatial_srid", - "spatial_set_srid", - "tspatialinst_srid", - "tpointseq_azimuth", - "tpointseq_cumulative_length", - "tpointseq_is_simple", - "tpointseq_length", - "tpointseq_linear_trajectory", - "tgeoseq_stboxes", - "tgeoseq_split_n_stboxes", - "tpointseqset_azimuth", - "tpointseqset_cumulative_length", - "tpointseqset_is_simple", - "tpointseqset_length", - "tgeoseqset_stboxes", - "tgeoseqset_split_n_stboxes", - "tpoint_get_coord", - "tgeominst_tgeoginst", - "tgeomseq_tgeogseq", - "tgeomseqset_tgeogseqset", - "tgeom_tgeog", - "tgeo_tpoint", - "tspatialinst_set_srid", - "tpointseq_make_simple", - "tspatialseq_set_srid", - "tpointseqset_make_simple", - "tspatialseqset_set_srid", - "tpointseq_twcentroid", - "tpointseqset_twcentroid", - "npoint_as_ewkt", - "npoint_as_hexwkb", - "npoint_as_text", - "npoint_as_wkb", - "npoint_from_hexwkb", - "npoint_from_wkb", - "npoint_in", - "npoint_out", - "nsegment_in", - "nsegment_out", - "npoint_make", - "nsegment_make", - "geompoint_to_npoint", - "geom_to_nsegment", - "npoint_to_geompoint", - "npoint_to_nsegment", - "npoint_to_stbox", - "nsegment_to_geom", - "nsegment_to_stbox", - "npoint_hash", - "npoint_hash_extended", - "npoint_position", - "npoint_route", - "nsegment_end_position", - "nsegment_route", - "nsegment_start_position", - "route_exists", - "route_geom", - "route_length", - "npoint_round", - "nsegment_round", - "get_srid_ways", - "npoint_srid", - "nsegment_srid", - "npoint_timestamptz_to_stbox", - "npoint_tstzspan_to_stbox", - "npoint_cmp", - "npoint_eq", - "npoint_ge", - "npoint_gt", - "npoint_le", - "npoint_lt", - "npoint_ne", - "npoint_same", - "nsegment_cmp", - "nsegment_eq", - "nsegment_ge", - "nsegment_gt", - "nsegment_le", - "nsegment_lt", - "nsegment_ne", - "npointset_in", - "npointset_out", - "npointset_make", - "npoint_to_set", - "npointset_end_value", - "npointset_routes", - "npointset_start_value", - "npointset_value_n", - "npointset_values", - "contained_npoint_set", - "contains_set_npoint", - "intersection_npoint_set", - "intersection_set_npoint", - "minus_npoint_set", - "minus_set_npoint", - "npoint_union_transfn", - "union_npoint_set", - "union_set_npoint", - "tnpoint_in", - "tnpoint_out", - "tnpointinst_make", - "tgeompoint_to_tnpoint", - "tnpoint_to_tgeompoint", - "tnpoint_cumulative_length", - "tnpoint_length", - "tnpoint_positions", - "tnpoint_route", - "tnpoint_routes", - "tnpoint_speed", - "tnpoint_trajectory", - "tnpoint_twcentroid", - "tnpoint_at_geom", - "tnpoint_at_npoint", - "tnpoint_at_npointset", - "tnpoint_at_stbox", - "tnpoint_minus_geom", - "tnpoint_minus_npoint", - "tnpoint_minus_npointset", - "tnpoint_minus_stbox", - "tdistance_tnpoint_npoint", - "tdistance_tnpoint_point", - "tdistance_tnpoint_tnpoint", - "nad_tnpoint_geo", - "nad_tnpoint_npoint", - "nad_tnpoint_stbox", - "nad_tnpoint_tnpoint", - "nai_tnpoint_geo", - "nai_tnpoint_npoint", - "nai_tnpoint_tnpoint", - "shortestline_tnpoint_geo", - "shortestline_tnpoint_npoint", - "shortestline_tnpoint_tnpoint", - "tnpoint_tcentroid_transfn", - "always_eq_npoint_tnpoint", - "always_eq_tnpoint_npoint", - "always_eq_tnpoint_tnpoint", - "always_ne_npoint_tnpoint", - "always_ne_tnpoint_npoint", - "always_ne_tnpoint_tnpoint", - "ever_eq_npoint_tnpoint", - "ever_eq_tnpoint_npoint", - "ever_eq_tnpoint_tnpoint", - "ever_ne_npoint_tnpoint", - "ever_ne_tnpoint_npoint", - "ever_ne_tnpoint_tnpoint", - "teq_tnpoint_npoint", - "tne_tnpoint_npoint", + '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', + 'float_to_datum', + 'int_to_datum', + 'tbox_expand_float', + 'tbox_expand_int', + 'tbox_shift_scale_float', + 'tbox_shift_scale_int', + 'date_in', + 'date_out', + 'interval_cmp', + 'interval_in', + 'interval_out', + 'time_in', + 'time_out', + 'timestamp_in', + 'timestamp_out', + 'timestamptz_in', + 'timestamptz_out', + 'rtree_create_intspan', + 'rtree_create_bigintspan', + 'rtree_create_floatspan', + 'rtree_create_datespan', + 'rtree_create_tstzspan', + 'rtree_create_tbox', + 'rtree_create_stbox', + 'rtree_free', + 'rtree_insert', + 'rtree_search', + 'meos_errno', + 'meos_errno_set', + 'meos_errno_restore', + 'meos_errno_reset', + 'meos_finalize_projsrs', + 'meos_finalize_ways', + 'meos_set_datestyle', + 'meos_set_intervalstyle', + 'meos_get_datestyle', + 'meos_get_intervalstyle', + 'meos_set_spatial_ref_sys_csv', + 'meos_initialize', + 'meos_finalize', + 'add_date_int', + 'add_interval_interval', + 'add_timestamptz_interval', + 'bool_in', + 'bool_out', + 'cstring2text', + 'date_to_timestamp', + 'date_to_timestamptz', + 'float_exp', + 'float_ln', + 'float_log10', + 'float8_out', + 'float_round', + 'int32_cmp', + 'int64_cmp', + 'interval_make', + 'minus_date_date', + 'minus_date_int', + 'minus_timestamptz_interval', + 'minus_timestamptz_timestamptz', + 'mul_interval_double', + 'pg_date_in', + 'pg_date_out', + 'pg_interval_cmp', + 'pg_interval_in', + 'pg_interval_out', + 'pg_timestamp_in', + 'pg_timestamp_out', + 'pg_timestamptz_in', + 'pg_timestamptz_out', + 'text2cstring', + 'text_cmp', + 'text_copy', + 'text_in', + 'text_initcap', + 'text_lower', + 'text_out', + 'text_upper', + 'textcat_text_text', + 'timestamptz_shift', + 'timestamp_to_date', + 'timestamptz_to_date', + 'bigintset_in', + 'bigintset_out', + 'bigintspan_expand', + '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_expand', + 'floatspan_in', + 'floatspan_out', + 'floatspanset_in', + 'floatspanset_out', + 'intset_in', + 'intset_out', + 'intspan_expand', + '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', + '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', + 'int_to_set', + 'int_to_span', + 'int_to_spanset', + 'intset_to_floatset', + 'intspan_to_floatspan', + 'intspanset_to_floatspanset', + 'set_to_span', + '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', + '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', + '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_spanarr', + '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_timestamps', + 'tstzspanset_timestamptz_n', + 'tstzspanset_upper', + 'bigintset_shift_scale', + 'bigintspan_shift_scale', + 'bigintspanset_shift_scale', + 'dateset_shift_scale', + 'datespan_shift_scale', + 'datespanset_shift_scale', + 'floatset_ceil', + 'floatset_degrees', + 'floatset_floor', + 'floatset_radians', + 'floatset_shift_scale', + 'floatspan_ceil', + 'floatspan_degrees', + 'floatspan_floor', + 'floatspan_radians', + 'floatspan_round', + 'floatspan_shift_scale', + 'floatspanset_ceil', + 'floatspanset_floor', + 'floatspanset_degrees', + 'floatspanset_radians', + 'floatspanset_round', + 'floatspanset_shift_scale', + 'intset_shift_scale', + 'intspan_shift_scale', + 'intspanset_shift_scale', + 'tstzspan_expand', + 'set_round', + 'textcat_text_textset', + 'textcat_textset_text', + 'textset_initcap', + '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', + 'set_spans', + 'set_split_each_n_spans', + 'set_split_n_spans', + 'spanset_spans', + 'spanset_split_each_n_spans', + 'spanset_split_n_spans', + '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_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_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_int_set', + 'intersection_set_bigint', + 'intersection_set_date', + 'intersection_set_float', + '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_int_set', + 'minus_int_span', + 'minus_int_spanset', + 'minus_set_bigint', + 'minus_set_date', + 'minus_set_float', + '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_int_set', + 'union_int_span', + 'union_int_spanset', + 'union_set_bigint', + 'union_set_date', + 'union_set_float', + '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', + 'bigint_get_bin', + 'bigintspan_bins', + 'bigintspanset_bins', + 'date_get_bin', + 'datespan_bins', + 'datespanset_bins', + 'float_get_bin', + 'floatspan_bins', + 'floatspanset_bins', + 'int_get_bin', + 'intspan_bins', + 'intspanset_bins', + 'timestamptz_get_bin', + 'tstzspan_bins', + 'tstzspanset_bins', + 'tbox_as_hexwkb', + 'tbox_as_wkb', + 'tbox_from_hexwkb', + 'tbox_from_wkb', + 'tbox_in', + 'tbox_out', + 'float_timestamptz_to_tbox', + 'float_tstzspan_to_tbox', + 'int_timestamptz_to_tbox', + 'int_tstzspan_to_tbox', + 'numspan_tstzspan_to_tbox', + 'numspan_timestamptz_to_tbox', + 'tbox_copy', + 'tbox_make', + 'float_to_tbox', + 'int_to_tbox', + 'set_to_tbox', + 'span_to_tbox', + 'spanset_to_tbox', + 'tbox_to_intspan', + 'tbox_to_floatspan', + 'tbox_to_tstzspan', + 'timestamptz_to_tbox', + 'tbox_hash', + 'tbox_hash_extended', + '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', + 'tbox_expand_time', + 'tbox_round', + 'tbox_shift_scale_time', + 'tfloatbox_expand', + 'tfloatbox_shift_scale', + 'tintbox_expand', + 'tintbox_shift_scale', + 'union_tbox_tbox', + 'intersection_tbox_tbox', + 'adjacent_tbox_tbox', + 'contained_tbox_tbox', + 'contains_tbox_tbox', + 'overlaps_tbox_tbox', + 'same_tbox_tbox', + 'after_tbox_tbox', + 'before_tbox_tbox', + 'left_tbox_tbox', + 'overafter_tbox_tbox', + 'overbefore_tbox_tbox', + 'overleft_tbox_tbox', + 'overright_tbox_tbox', + 'right_tbox_tbox', + 'tbox_cmp', + 'tbox_eq', + 'tbox_ge', + 'tbox_gt', + 'tbox_le', + 'tbox_lt', + 'tbox_ne', + 'tbool_from_mfjson', + 'tbool_in', + 'tbool_out', + 'temporal_as_hexwkb', + 'temporal_as_mfjson', + 'temporal_as_wkb', + 'temporal_from_hexwkb', + 'temporal_from_wkb', + 'tfloat_from_mfjson', + 'tfloat_in', + 'tfloat_out', + 'tint_from_mfjson', + 'tint_in', + 'tint_out', + 'ttext_from_mfjson', + '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_tstzset', + 'tfloatseq_from_base_tstzspan', + 'tfloatseqset_from_base_tstzspanset', + 'tint_from_base_temp', + 'tintinst_make', + 'tintseq_from_base_tstzset', + 'tintseq_from_base_tstzspan', + 'tintseqset_from_base_tstzspanset', + 'tsequence_make', + 'tsequenceset_make', + 'tsequenceset_make_gaps', + 'ttext_from_base_temp', + 'ttextinst_make', + 'ttextseq_from_base_tstzset', + 'ttextseq_from_base_tstzspan', + 'ttextseqset_from_base_tstzspanset', + 'tbool_to_tint', + 'temporal_to_tstzspan', + 'tfloat_to_tint', + 'tint_to_tfloat', + 'tnumber_to_span', + 'tnumber_to_tbox', + 'tbool_end_value', + 'tbool_start_value', + 'tbool_value_at_timestamptz', + 'tbool_value_n', + 'tbool_values', + 'temporal_duration', + 'temporal_end_instant', + 'temporal_end_sequence', + 'temporal_end_timestamptz', + 'temporal_hash', + 'temporal_instant_n', + 'temporal_instants', + 'temporal_interp', + 'temporal_lower_inc', + 'temporal_max_instant', + 'temporal_min_instant', + 'temporal_num_instants', + 'temporal_num_sequences', + 'temporal_num_timestamps', + 'temporal_segm_duration', + 'temporal_segments', + 'temporal_sequence_n', + 'temporal_sequences', + 'temporal_start_instant', + 'temporal_start_sequence', + 'temporal_start_timestamptz', + 'temporal_stops', + 'temporal_subtype', + 'temporal_time', + 'temporal_timestamps', + 'temporal_timestamptz_n', + 'temporal_upper_inc', + 'tfloat_end_value', + 'tfloat_min_value', + 'tfloat_max_value', + 'tfloat_start_value', + 'tfloat_value_at_timestamptz', + 'tfloat_value_n', + 'tfloat_values', + 'tint_end_value', + 'tint_max_value', + 'tint_min_value', + 'tint_start_value', + 'tint_value_at_timestamptz', + 'tint_value_n', + 'tint_values', + 'tnumber_avg_value', + 'tnumber_integral', + 'tnumber_twavg', + 'tnumber_valuespans', + 'ttext_end_value', + 'ttext_max_value', + 'ttext_min_value', + 'ttext_start_value', + 'ttext_value_at_timestamptz', + 'ttext_value_n', + 'ttext_values', + 'float_degrees', + 'temparr_round', + 'temporal_round', + 'temporal_scale_time', + 'temporal_set_interp', + 'temporal_shift_scale_time', + 'temporal_shift_time', + 'temporal_to_tinstant', + 'temporal_to_tsequence', + 'temporal_to_tsequenceset', + 'tfloat_ceil', + 'tfloat_degrees', + 'tfloat_floor', + 'tfloat_radians', + '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_timestamptz', + 'temporal_delete_tstzset', + 'temporal_delete_tstzspan', + 'temporal_delete_tstzspanset', + 'temporal_insert', + 'temporal_merge', + 'temporal_merge_array', + 'temporal_update', + 'tbool_at_value', + 'tbool_minus_value', + 'temporal_after_timestamptz', + 'temporal_at_max', + 'temporal_at_min', + 'temporal_at_timestamptz', + 'temporal_at_tstzset', + 'temporal_at_tstzspan', + 'temporal_at_tstzspanset', + 'temporal_at_values', + 'temporal_before_timestamptz', + 'temporal_minus_max', + 'temporal_minus_min', + 'temporal_minus_timestamptz', + 'temporal_minus_tstzset', + 'temporal_minus_tstzspan', + 'temporal_minus_tstzspanset', + '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', + '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_tbool_bool', + 'always_eq_temporal_temporal', + 'always_eq_text_ttext', + 'always_eq_tfloat_float', + 'always_eq_tint_int', + 'always_eq_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', + 'always_ne_bool_tbool', + 'always_ne_float_tfloat', + 'always_ne_int_tint', + 'always_ne_tbool_bool', + 'always_ne_temporal_temporal', + 'always_ne_text_ttext', + 'always_ne_tfloat_float', + 'always_ne_tint_int', + 'always_ne_ttext_text', + 'ever_eq_bool_tbool', + 'ever_eq_float_tfloat', + 'ever_eq_int_tint', + 'ever_eq_tbool_bool', + 'ever_eq_temporal_temporal', + 'ever_eq_text_ttext', + 'ever_eq_tfloat_float', + 'ever_eq_tint_int', + '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_tbool_bool', + 'ever_ne_temporal_temporal', + 'ever_ne_text_ttext', + 'ever_ne_tfloat_float', + 'ever_ne_tint_int', + 'ever_ne_ttext_text', + 'teq_bool_tbool', + 'teq_float_tfloat', + 'teq_int_tint', + 'teq_tbool_bool', + 'teq_temporal_temporal', + 'teq_text_ttext', + 'teq_tfloat_float', + '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_tbool_bool', + 'tne_temporal_temporal', + 'tne_text_ttext', + 'tne_tfloat_float', + 'tne_tint_int', + 'tne_ttext_text', + 'temporal_spans', + 'temporal_split_each_n_spans', + 'temporal_split_n_spans', + 'tnumber_split_each_n_tboxes', + 'tnumber_split_n_tboxes', + 'tnumber_tboxes', + 'adjacent_numspan_tnumber', + 'adjacent_tbox_tnumber', + 'adjacent_temporal_temporal', + 'adjacent_temporal_tstzspan', + 'adjacent_tnumber_numspan', + 'adjacent_tnumber_tbox', + 'adjacent_tnumber_tnumber', + 'adjacent_tstzspan_temporal', + 'contained_numspan_tnumber', + 'contained_tbox_tnumber', + 'contained_temporal_temporal', + 'contained_temporal_tstzspan', + 'contained_tnumber_numspan', + 'contained_tnumber_tbox', + 'contained_tnumber_tnumber', + 'contained_tstzspan_temporal', + 'contains_numspan_tnumber', + 'contains_tbox_tnumber', + 'contains_temporal_tstzspan', + 'contains_temporal_temporal', + 'contains_tnumber_numspan', + 'contains_tnumber_tbox', + 'contains_tnumber_tnumber', + 'contains_tstzspan_temporal', + 'overlaps_numspan_tnumber', + 'overlaps_tbox_tnumber', + 'overlaps_temporal_temporal', + 'overlaps_temporal_tstzspan', + 'overlaps_tnumber_numspan', + 'overlaps_tnumber_tbox', + 'overlaps_tnumber_tnumber', + 'overlaps_tstzspan_temporal', + 'same_numspan_tnumber', + 'same_tbox_tnumber', + 'same_temporal_temporal', + 'same_temporal_tstzspan', + 'same_tnumber_numspan', + 'same_tnumber_tbox', + 'same_tnumber_tnumber', + 'same_tstzspan_temporal', + 'after_tbox_tnumber', + 'after_temporal_tstzspan', + 'after_temporal_temporal', + 'after_tnumber_tbox', + 'after_tnumber_tnumber', + 'after_tstzspan_temporal', + 'before_tbox_tnumber', + 'before_temporal_tstzspan', + 'before_temporal_temporal', + 'before_tnumber_tbox', + 'before_tnumber_tnumber', + 'before_tstzspan_temporal', + 'left_tbox_tnumber', + 'left_numspan_tnumber', + 'left_tnumber_numspan', + 'left_tnumber_tbox', + 'left_tnumber_tnumber', + 'overafter_tbox_tnumber', + 'overafter_temporal_tstzspan', + 'overafter_temporal_temporal', + 'overafter_tnumber_tbox', + 'overafter_tnumber_tnumber', + 'overafter_tstzspan_temporal', + 'overbefore_tbox_tnumber', + 'overbefore_temporal_tstzspan', + 'overbefore_temporal_temporal', + 'overbefore_tnumber_tbox', + 'overbefore_tnumber_tnumber', + 'overbefore_tstzspan_temporal', + 'overleft_numspan_tnumber', + 'overleft_tbox_tnumber', + 'overleft_tnumber_numspan', + 'overleft_tnumber_tbox', + 'overleft_tnumber_tnumber', + 'overright_numspan_tnumber', + 'overright_tbox_tnumber', + 'overright_tnumber_numspan', + 'overright_tnumber_tbox', + 'overright_tnumber_tnumber', + 'right_numspan_tnumber', + 'right_tbox_tnumber', + 'right_tnumber_numspan', + 'right_tnumber_tbox', + 'right_tnumber_tnumber', + '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', + 'temporal_derivative', + 'tfloat_exp', + 'tfloat_ln', + 'tfloat_log10', + 'tnumber_abs', + 'tnumber_trend', + 'float_angular_difference', + 'tnumber_angular_difference', + 'tnumber_delta_value', + 'textcat_text_ttext', + 'textcat_ttext_text', + 'textcat_ttext_ttext', + 'ttext_initcap', + 'ttext_upper', + 'ttext_lower', + 'tdistance_tfloat_float', + 'tdistance_tint_int', + 'tdistance_tnumber_tnumber', + 'nad_tboxfloat_tboxfloat', + 'nad_tboxint_tboxint', + 'nad_tfloat_float', + 'nad_tfloat_tfloat', + 'nad_tfloat_tbox', + 'nad_tint_int', + 'nad_tint_tbox', + 'nad_tint_tint', + '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', + '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', + 'temporal_time_bins', + 'temporal_time_split', + 'tfloat_time_boxes', + 'tfloat_value_bins', + 'tfloat_value_boxes', + 'tfloat_value_split', + 'tfloat_value_time_boxes', + 'tfloat_value_time_split', + 'tfloatbox_time_tiles', + 'tfloatbox_value_tiles', + 'tfloatbox_value_time_tiles', + 'tint_time_boxes', + 'tint_value_bins', + 'tint_value_boxes', + 'tint_value_split', + 'tint_value_time_boxes', + 'tint_value_time_split', + 'tintbox_time_tiles', + 'tintbox_value_tiles', + 'tintbox_value_time_tiles', + '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', + 'tnumber_basetype', + 'geo_basetype', + 'time_type', + 'set_type', + 'numset_type', + 'ensure_numset_type', + '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', + 'type_span_bbox', + 'span_tbox_type', + 'ensure_span_tbox_type', + 'numspan_basetype', + 'numspan_type', + 'ensure_numspan_type', + 'timespan_basetype', + 'timespan_type', + 'spanset_type', + 'timespanset_type', + 'ensure_timespanset_type', + 'temporal_type', + 'temptype_continuous', + 'basetype_byvalue', + 'basetype_varlength', + 'basetype_length', + 'talpha_type', + 'tnumber_type', + 'ensure_tnumber_type', + 'ensure_tnumber_basetype', + 'tnumber_spantype', + 'spatial_basetype', + 'tspatial_type', + 'ensure_tspatial_type', + 'tpoint_type', + 'ensure_tpoint_type', + 'tgeo_type', + 'ensure_tgeo_type', + 'tgeo_type_all', + 'ensure_tgeo_type_all', + 'tgeometry_type', + 'ensure_tgeometry_type', + 'tgeodetic_type', + 'ensure_tgeodetic_type', + 'ensure_tnumber_tpoint_type', + 'geo_as_ewkb', + 'geo_as_ewkt', + 'geo_as_geojson', + 'geo_as_hexewkb', + 'geo_as_text', + 'geo_from_ewkb', + 'geo_from_geojson', + 'geo_from_text', + 'geo_out', + 'geog_from_hexewkb', + 'geog_in', + 'geom_from_hexewkb', + 'geom_in', + 'box3d_make', + 'box3d_out', + 'gbox_make', + 'gbox_out', + 'geo_copy', + 'geogpoint_make2d', + 'geogpoint_make3dz', + 'geompoint_make2d', + 'geompoint_make3dz', + 'geom_to_geog', + 'geog_to_geom', + 'geo_is_empty', + 'geo_is_unitary', + 'geo_typename', + 'geog_area', + 'geog_centroid', + 'geog_length', + 'geog_perimeter', + 'geom_azimuth', + 'geom_length', + 'geom_perimeter', + 'line_numpoints', + 'line_point_n', + 'geo_reverse', + 'geo_round', + 'geo_set_srid', + 'geo_srid', + 'geo_transform', + 'geo_transform_pipeline', + 'geo_collect_garray', + 'geo_makeline_garray', + 'geo_num_points', + 'geo_num_geos', + 'geo_geo_n', + 'geo_pointarr', + 'geo_points', + 'geom_array_union', + 'geom_boundary', + 'geom_buffer', + 'geom_centroid', + 'geom_convex_hull', + 'geom_difference2d', + 'geom_intersection2d', + 'geom_intersection2d_coll', + 'geom_min_bounding_radius', + 'geom_shortestline2d', + 'geom_shortestline3d', + 'geom_unary_union', + 'line_interpolate_point', + 'line_locate_point', + 'line_substring', + 'geog_dwithin', + 'geog_intersects', + 'geom_contains', + 'geom_covers', + 'geom_disjoint2d', + 'geom_dwithin2d', + 'geom_dwithin3d', + 'geom_intersects2d', + 'geom_intersects3d', + 'geom_relate_pattern', + 'geom_touches', + 'geo_stboxes', + 'geo_split_each_n_stboxes', + 'geo_split_n_stboxes', + 'geog_distance', + 'geom_distance2d', + 'geom_distance3d', + 'geo_equals', + 'geo_same', + 'geogset_in', + 'geomset_in', + 'spatialset_as_text', + 'spatialset_as_ewkt', + 'geoset_make', + 'geo_to_set', + 'geoset_end_value', + 'geoset_start_value', + 'geoset_value_n', + 'geoset_values', + 'contained_geo_set', + 'contains_set_geo', + 'geo_union_transfn', + 'intersection_geo_set', + 'intersection_set_geo', + 'minus_geo_set', + 'minus_set_geo', + 'union_geo_set', + 'union_set_geo', + 'spatialset_set_srid', + 'spatialset_srid', + 'spatialset_transform', + 'spatialset_transform_pipeline', + 'stbox_as_hexwkb', + 'stbox_as_wkb', + 'stbox_from_hexwkb', + 'stbox_from_wkb', + 'stbox_in', + 'stbox_out', + 'geo_timestamptz_to_stbox', + 'geo_tstzspan_to_stbox', + 'stbox_copy', + 'stbox_make', + 'geo_to_stbox', + 'spatialset_to_stbox', + 'stbox_to_box3d', + 'stbox_to_gbox', + 'stbox_to_geo', + 'stbox_to_tstzspan', + 'timestamptz_to_stbox', + 'tstzset_to_stbox', + 'tstzspan_to_stbox', + 'tstzspanset_to_stbox', + 'stbox_area', + 'stbox_hash', + 'stbox_hash_extended', + 'stbox_hast', + 'stbox_hasx', + 'stbox_hasz', + 'stbox_isgeodetic', + 'stbox_perimeter', + 'stbox_tmax', + 'stbox_tmax_inc', + 'stbox_tmin', + 'stbox_tmin_inc', + 'stbox_volume', + 'stbox_xmax', + 'stbox_xmin', + 'stbox_ymax', + 'stbox_ymin', + 'stbox_zmax', + 'stbox_zmin', + 'stbox_expand_space', + 'stbox_expand_time', + 'stbox_get_space', + 'stbox_quad_split', + 'stbox_round', + 'stbox_shift_scale_time', + 'stboxarr_round', + 'stbox_set_srid', + 'stbox_srid', + 'stbox_transform', + 'stbox_transform_pipeline', + 'adjacent_stbox_stbox', + 'contained_stbox_stbox', + 'contains_stbox_stbox', + 'overlaps_stbox_stbox', + 'same_stbox_stbox', + 'above_stbox_stbox', + 'after_stbox_stbox', + 'back_stbox_stbox', + 'before_stbox_stbox', + 'below_stbox_stbox', + 'front_stbox_stbox', + 'left_stbox_stbox', + 'overabove_stbox_stbox', + 'overafter_stbox_stbox', + 'overback_stbox_stbox', + 'overbefore_stbox_stbox', + 'overbelow_stbox_stbox', + 'overfront_stbox_stbox', + 'overleft_stbox_stbox', + 'overright_stbox_stbox', + 'right_stbox_stbox', + 'union_stbox_stbox', + 'intersection_stbox_stbox', + 'stbox_cmp', + 'stbox_eq', + 'stbox_ge', + 'stbox_gt', + 'stbox_le', + 'stbox_lt', + 'stbox_ne', + 'tgeogpoint_from_mfjson', + 'tgeogpoint_in', + 'tgeography_from_mfjson', + 'tgeography_in', + 'tgeometry_from_mfjson', + 'tgeometry_in', + 'tgeompoint_from_mfjson', + 'tgeompoint_in', + 'tspatial_as_ewkt', + 'tspatial_as_text', + 'tspatial_out', + 'tgeo_from_base_temp', + 'tgeoinst_make', + 'tgeoseq_from_base_tstzset', + 'tgeoseq_from_base_tstzspan', + 'tgeoseqset_from_base_tstzspanset', + 'tpoint_from_base_temp', + 'tpointinst_make', + 'tpointseq_from_base_tstzset', + 'tpointseq_from_base_tstzspan', + 'tpointseq_make_coords', + 'tpointseqset_from_base_tstzspanset', + 'box3d_to_stbox', + 'gbox_to_stbox', + 'geomeas_to_tpoint', + 'tgeogpoint_to_tgeography', + 'tgeography_to_tgeogpoint', + 'tgeography_to_tgeometry', + 'tgeometry_to_tgeography', + 'tgeometry_to_tgeompoint', + 'tgeompoint_to_tgeometry', + 'tpoint_as_mvtgeom', + 'tpoint_tfloat_to_geomeas', + 'tspatial_to_stbox', + 'bearing_point_point', + 'bearing_tpoint_point', + 'bearing_tpoint_tpoint', + 'tgeo_centroid', + 'tgeo_convex_hull', + 'tgeo_end_value', + 'tgeo_start_value', + 'tgeo_traversed_area', + 'tgeo_value_at_timestamptz', + 'tgeo_value_n', + 'tgeo_values', + 'tpoint_angular_difference', + 'tpoint_azimuth', + 'tpoint_cumulative_length', + 'tpoint_direction', + 'tpoint_get_x', + 'tpoint_get_y', + 'tpoint_get_z', + 'tpoint_is_simple', + 'tpoint_length', + 'tpoint_speed', + 'tpoint_trajectory', + 'tpoint_twcentroid', + 'tgeo_affine', + 'tgeo_scale', + 'tpoint_make_simple', + 'tspatial_srid', + 'tspatial_set_srid', + 'tspatial_transform', + 'tspatial_transform_pipeline', + 'tgeo_at_geom', + 'tgeo_at_stbox', + 'tgeo_at_value', + 'tgeo_minus_geom', + 'tgeo_minus_stbox', + 'tgeo_minus_value', + 'tpoint_at_geom', + 'tpoint_at_value', + 'tpoint_minus_geom', + 'tpoint_minus_value', + 'always_eq_geo_tgeo', + 'always_eq_tgeo_geo', + 'always_eq_tgeo_tgeo', + 'always_ne_geo_tgeo', + 'always_ne_tgeo_geo', + 'always_ne_tgeo_tgeo', + 'ever_eq_geo_tgeo', + 'ever_eq_tgeo_geo', + 'ever_eq_tgeo_tgeo', + 'ever_ne_geo_tgeo', + 'ever_ne_tgeo_geo', + 'ever_ne_tgeo_tgeo', + 'teq_geo_tgeo', + 'teq_tgeo_geo', + 'tne_geo_tgeo', + 'tne_tgeo_geo', + 'tgeo_stboxes', + 'tgeo_space_boxes', + 'tgeo_space_time_boxes', + 'tgeo_split_each_n_stboxes', + 'tgeo_split_n_stboxes', + 'adjacent_stbox_tspatial', + 'adjacent_tspatial_stbox', + 'adjacent_tspatial_tspatial', + 'contained_stbox_tspatial', + 'contained_tspatial_stbox', + 'contained_tspatial_tspatial', + 'contains_stbox_tspatial', + 'contains_tspatial_stbox', + 'contains_tspatial_tspatial', + 'overlaps_stbox_tspatial', + 'overlaps_tspatial_stbox', + 'overlaps_tspatial_tspatial', + 'same_stbox_tspatial', + 'same_tspatial_stbox', + 'same_tspatial_tspatial', + 'above_stbox_tspatial', + 'above_tspatial_stbox', + 'above_tspatial_tspatial', + 'after_stbox_tspatial', + 'after_tspatial_stbox', + 'after_tspatial_tspatial', + 'back_stbox_tspatial', + 'back_tspatial_stbox', + 'back_tspatial_tspatial', + 'before_stbox_tspatial', + 'before_tspatial_stbox', + 'before_tspatial_tspatial', + 'below_stbox_tspatial', + 'below_tspatial_stbox', + 'below_tspatial_tspatial', + 'front_stbox_tspatial', + 'front_tspatial_stbox', + 'front_tspatial_tspatial', + 'left_stbox_tspatial', + 'left_tspatial_stbox', + 'left_tspatial_tspatial', + 'overabove_stbox_tspatial', + 'overabove_tspatial_stbox', + 'overabove_tspatial_tspatial', + 'overafter_stbox_tspatial', + 'overafter_tspatial_stbox', + 'overafter_tspatial_tspatial', + 'overback_stbox_tspatial', + 'overback_tspatial_stbox', + 'overback_tspatial_tspatial', + 'overbefore_stbox_tspatial', + 'overbefore_tspatial_stbox', + 'overbefore_tspatial_tspatial', + 'overbelow_stbox_tspatial', + 'overbelow_tspatial_stbox', + 'overbelow_tspatial_tspatial', + 'overfront_stbox_tspatial', + 'overfront_tspatial_stbox', + 'overfront_tspatial_tspatial', + 'overleft_stbox_tspatial', + 'overleft_tspatial_stbox', + 'overleft_tspatial_tspatial', + 'overright_stbox_tspatial', + 'overright_tspatial_stbox', + 'overright_tspatial_tspatial', + 'right_stbox_tspatial', + 'right_tspatial_stbox', + 'right_tspatial_tspatial', + 'acontains_geo_tgeo', + 'acontains_tgeo_geo', + 'acontains_tgeo_tgeo', + 'adisjoint_tgeo_geo', + 'adisjoint_tgeo_tgeo', + 'adwithin_tgeo_geo', + 'adwithin_tgeo_tgeo', + 'aintersects_tgeo_geo', + 'aintersects_tgeo_tgeo', + 'atouches_tgeo_geo', + 'atouches_tgeo_tgeo', + 'atouches_tpoint_geo', + 'econtains_geo_tgeo', + 'econtains_tgeo_geo', + 'econtains_tgeo_tgeo', + 'ecovers_geo_tgeo', + 'ecovers_tgeo_geo', + 'ecovers_tgeo_tgeo', + 'edisjoint_tgeo_geo', + 'edisjoint_tgeo_tgeo', + 'edwithin_tgeo_geo', + 'edwithin_tgeo_tgeo', + 'eintersects_tgeo_geo', + 'eintersects_tgeo_tgeo', + 'etouches_tgeo_geo', + 'etouches_tgeo_tgeo', + 'etouches_tpoint_geo', + 'tcontains_geo_tgeo', + 'tcontains_tgeo_geo', + 'tcontains_tgeo_tgeo', + 'tcovers_geo_tgeo', + 'tcovers_tgeo_geo', + 'tcovers_tgeo_tgeo', + 'tdisjoint_geo_tgeo', + 'tdisjoint_tgeo_geo', + 'tdisjoint_tgeo_tgeo', + 'tdwithin_geo_tgeo', + 'tdwithin_tgeo_geo', + 'tdwithin_tgeo_tgeo', + 'tintersects_geo_tgeo', + 'tintersects_tgeo_geo', + 'tintersects_tgeo_tgeo', + 'ttouches_geo_tgeo', + 'ttouches_tgeo_geo', + 'ttouches_tgeo_tgeo', + 'tdistance_tgeo_geo', + 'tdistance_tgeo_tgeo', + 'nad_stbox_geo', + 'nad_stbox_stbox', + 'nad_tgeo_geo', + 'nad_tgeo_stbox', + 'nad_tgeo_tgeo', + 'nai_tgeo_geo', + 'nai_tgeo_tgeo', + 'shortestline_tgeo_geo', + 'shortestline_tgeo_tgeo', + 'tpoint_tcentroid_finalfn', + 'tpoint_tcentroid_transfn', + 'tspatial_extent_transfn', + 'stbox_get_space_tile', + 'stbox_get_space_time_tile', + 'stbox_get_time_tile', + 'stbox_space_tiles', + 'stbox_space_time_tiles', + 'stbox_time_tiles', + 'tgeo_space_split', + 'tgeo_space_time_split', + 'geo_cluster_kmeans', + 'geo_cluster_dbscan', + 'geo_cluster_intersecting', + 'geo_cluster_within', + 'gsl_get_generation_rng', + 'gsl_get_aggregation_rng', + 'datum_ceil', + 'datum_degrees', + 'datum_float_round', + 'datum_floor', + 'datum_hash', + 'datum_hash_extended', + 'datum_radians', + 'floatspan_round_set', + 'set_in', + 'set_out', + 'span_in', + 'span_out', + 'spanset_in', + 'spanset_out', + 'set_make', + 'set_make_exp', + 'set_make_free', + 'span_make', + 'span_set', + 'spanset_make_exp', + 'spanset_make_free', + 'set_span', + 'set_spanset', + 'value_set_span', + 'value_set', + 'value_span', + 'value_spanset', + 'numspan_width', + 'numspanset_width', + 'set_end_value', + 'set_mem_size', + 'set_set_subspan', + 'set_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_set_intspan', + 'intspan_set_floatspan', + 'numset_shift_scale', + 'numspan_expand', + 'numspan_shift_scale', + 'numspanset_shift_scale', + 'set_compact', + 'span_expand', + 'spanset_compact', + 'tbox_expand_value', + 'textcat_textset_text_common', + 'tstzspan_set_datespan', + 'adjacent_span_value', + 'adjacent_spanset_value', + 'adjacent_value_spanset', + 'contained_value_set', + 'contained_value_span', + 'contained_value_spanset', + 'contains_set_value', + 'contains_span_value', + 'contains_spanset_value', + 'ovadj_span_span', + 'left_set_value', + 'left_span_value', + 'left_spanset_value', + 'left_value_set', + 'left_value_span', + 'left_value_spanset', + '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', + 'right_value_set', + 'right_set_value', + 'right_value_span', + 'right_value_spanset', + 'right_span_value', + 'right_spanset_value', + 'bbox_type', + 'bbox_get_size', + 'bbox_max_dims', + 'temporal_bbox_eq', + 'temporal_bbox_cmp', + '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', + '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', + 'tbox_set', + 'float_set_tbox', + 'int_set_tbox', + 'number_set_tbox', + 'number_tbox', + 'numset_set_tbox', + 'numspan_set_tbox', + 'timestamptz_set_tbox', + 'tstzset_set_tbox', + 'tstzspan_set_tbox', + 'tbox_shift_scale_value', + 'tbox_expand', + 'inter_tbox_tbox', + 'tboolinst_in', + 'tboolseq_in', + 'tboolseqset_in', + 'temporal_in', + 'temporal_out', + 'temparr_out', + 'tfloatinst_in', + 'tfloatseq_in', + 'tfloatseqset_in', + 'tinstant_in', + 'tinstant_out', + 'tintinst_in', + 'tintseq_in', + 'tintseqset_in', + 'tsequence_in', + 'tsequence_out', + 'tsequenceset_in', + 'tsequenceset_out', + 'ttextinst_in', + 'ttextseq_in', + 'ttextseqset_in', + 'temporal_from_mfjson', + 'temporal_from_base_temp', + 'tinstant_copy', + 'tinstant_make', + 'tinstant_make_free', + 'tsequence_copy', + 'tsequence_from_base_temp', + 'tsequence_from_base_tstzset', + 'tsequence_from_base_tstzspan', + 'tsequence_make_exp', + 'tsequence_make_free', + 'tsequenceset_copy', + 'tseqsetarr_to_tseqset', + 'tsequenceset_from_base_temp', + 'tsequenceset_from_base_tstzspanset', + 'tsequenceset_make_exp', + 'tsequenceset_make_free', + 'temporal_set_tstzspan', + 'tinstant_set_tstzspan', + 'tnumber_set_tbox', + 'tnumberinst_set_tbox', + 'tnumberseq_set_tbox', + 'tnumberseqset_set_tbox', + 'tsequence_set_tstzspan', + 'tsequenceset_set_tstzspan', + 'temporal_end_inst', + 'temporal_end_value', + 'temporal_inst_n', + 'temporal_insts_p', + 'temporal_max_inst_p', + 'temporal_max_value', + 'temporal_mem_size', + 'temporal_min_inst_p', + 'temporal_min_value', + 'temporal_sequences_p', + 'temporal_set_bbox', + 'temporal_start_inst', + 'temporal_start_value', + 'temporal_values_p', + 'temporal_value_n', + 'temporal_values', + 'tinstant_hash', + 'tinstant_insts', + 'tinstant_set_bbox', + 'tinstant_time', + 'tinstant_timestamps', + 'tinstant_value_p', + 'tinstant_value', + 'tinstant_value_at_timestamptz', + 'tinstant_values_p', + 'tnumber_set_span', + 'tnumberinst_valuespans', + 'tnumberseq_avg_val', + 'tnumberseq_valuespans', + 'tnumberseqset_avg_val', + 'tnumberseqset_valuespans', + 'tsequence_duration', + 'tsequence_end_timestamptz', + 'tsequence_hash', + 'tsequence_insts_p', + 'tsequence_max_inst_p', + 'tsequence_max_val', + 'tsequence_min_inst_p', + 'tsequence_min_val', + 'tsequence_segments', + 'tsequence_seqs', + 'tsequence_start_timestamptz', + 'tsequence_time', + 'tsequence_timestamps', + 'tsequence_value_at_timestamptz', + 'tsequence_values_p', + 'tsequenceset_duration', + 'tsequenceset_end_timestamptz', + 'tsequenceset_hash', + 'tsequenceset_inst_n', + 'tsequenceset_insts_p', + 'tsequenceset_max_inst_p', + 'tsequenceset_max_val', + 'tsequenceset_min_inst_p', + 'tsequenceset_min_val', + 'tsequenceset_num_instants', + 'tsequenceset_num_timestamps', + 'tsequenceset_segments', + 'tsequenceset_sequences_p', + 'tsequenceset_start_timestamptz', + 'tsequenceset_time', + 'tsequenceset_timestamptz_n', + 'tsequenceset_timestamps', + 'tsequenceset_value_at_timestamptz', + 'tsequenceset_value_n', + 'tsequenceset_values_p', + 'temporal_restart', + 'temporal_tsequence', + 'temporal_tsequenceset', + 'tinstant_shift_time', + 'tinstant_to_tsequence', + 'tinstant_to_tsequence_free', + 'tinstant_to_tsequenceset', + 'tnumber_shift_scale_value', + 'tnumberinst_shift_value', + 'tnumberseq_shift_scale_value', + 'tnumberseqset_shift_scale_value', + 'tsequence_restart', + 'tsequence_set_interp', + 'tsequence_shift_scale_time', + 'tsequence_subseq', + 'tsequence_to_tinstant', + 'tsequence_to_tsequenceset', + 'tsequence_to_tsequenceset_free', + 'tsequence_to_tsequenceset_interp', + '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', + 'tcontseq_after_timestamptz', + 'tcontseq_before_timestamptz', + 'tcontseq_restrict_minmax', + 'tdiscseq_after_timestamptz', + 'tdiscseq_before_timestamptz', + 'tdiscseq_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_after_timestamptz', + 'tinstant_before_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', + 'tsequence_at_timestamptz', + 'tsequence_restrict_tstzspan', + 'tsequence_restrict_tstzspanset', + 'tsequenceset_after_timestamptz', + 'tsequenceset_before_timestamptz', + '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_ne_base_temporal', + 'always_ne_temporal_base', + 'always_ge_base_temporal', + 'always_ge_temporal_base', + 'always_gt_base_temporal', + 'always_gt_temporal_base', + 'always_le_base_temporal', + 'always_le_temporal_base', + 'always_lt_base_temporal', + 'always_lt_temporal_base', + 'ever_eq_base_temporal', + 'ever_eq_temporal_base', + 'ever_ne_base_temporal', + 'ever_ne_temporal_base', + 'ever_ge_base_temporal', + 'ever_ge_temporal_base', + 'ever_gt_base_temporal', + 'ever_gt_temporal_base', + 'ever_le_base_temporal', + 'ever_le_temporal_base', + 'ever_lt_base_temporal', + 'ever_lt_temporal_base', + 'tnumberinst_abs', + 'tnumberseq_abs', + 'tnumberseq_angular_difference', + 'tnumberseq_delta_value', + 'tnumberseqset_abs', + 'tnumberseqset_angular_difference', + 'tnumberseqset_delta_value', + 'tdistance_tnumber_number', + 'nad_tbox_tbox', + 'nad_tnumber_number', + 'nad_tnumber_tbox', + 'nad_tnumber_tnumber', + 'tnumberseq_integral', + 'tnumberseq_twavg', + 'tnumberseqset_integral', + 'tnumberseqset_twavg', + 'temporal_compact', + 'tsequence_compact', + 'tsequenceset_compact', + 'temporal_skiplist_make', + 'skiplist_search', + 'skiplist_free', + 'skiplist_splice', + 'temporal_skiplist_splice', + 'skiplist_values', + 'skiplist_keys_values', + 'temporal_app_tinst_transfn', + 'temporal_app_tseq_transfn', + 'span_bins', + 'spanset_bins', + 'tnumber_value_bins', + 'tnumber_value_time_boxes', + 'tnumber_value_split', + 'tbox_get_value_time_tile', + 'tnumber_value_time_split', + 'proj_get_context', + 'datum_geo_round', + 'point_round', + 'stbox_set', + 'gbox_set_stbox', + 'geo_set_stbox', + 'geoarr_set_stbox', + 'spatial_set_stbox', + 'spatialset_set_stbox', + 'stbox_set_box3d', + 'stbox_set_gbox', + 'tstzset_set_stbox', + 'tstzspan_set_stbox', + 'tstzspanset_set_stbox', + 'stbox_expand', + 'inter_stbox_stbox', + 'stbox_geo', + 'tgeogpointinst_in', + 'tgeogpointseq_in', + 'tgeogpointseqset_in', + 'tgeompointinst_in', + 'tgeompointseq_in', + 'tgeompointseqset_in', + 'tgeographyinst_in', + 'tgeographyseq_in', + 'tgeographyseqset_in', + 'tgeometryinst_in', + 'tgeometryseq_in', + 'tgeometryseqset_in', + 'tspatial_set_stbox', + 'tgeoinst_set_stbox', + 'tspatialseq_set_stbox', + 'tspatialseqset_set_stbox', + 'tgeo_restrict_geom', + 'tgeo_restrict_stbox', + 'tgeoinst_restrict_geom', + 'tgeoinst_restrict_stbox', + 'tgeoseq_restrict_geom', + 'tgeoseq_restrict_stbox', + 'tgeoseqset_restrict_geom', + 'tgeoseqset_restrict_stbox', + 'spatial_srid', + 'spatial_set_srid', + 'tspatialinst_srid', + 'tpointseq_azimuth', + 'tpointseq_cumulative_length', + 'tpointseq_is_simple', + 'tpointseq_length', + 'tpointseq_linear_trajectory', + 'tgeoseq_stboxes', + 'tgeoseq_split_n_stboxes', + 'tpointseqset_azimuth', + 'tpointseqset_cumulative_length', + 'tpointseqset_is_simple', + 'tpointseqset_length', + 'tgeoseqset_stboxes', + 'tgeoseqset_split_n_stboxes', + 'tpoint_get_coord', + 'tgeominst_tgeoginst', + 'tgeomseq_tgeogseq', + 'tgeomseqset_tgeogseqset', + 'tgeom_tgeog', + 'tgeo_tpoint', + 'tspatialinst_set_srid', + 'tpointseq_make_simple', + 'tspatialseq_set_srid', + 'tpointseqset_make_simple', + 'tspatialseqset_set_srid', + 'tpointseq_twcentroid', + 'tpointseqset_twcentroid', + 'npoint_as_ewkt', + 'npoint_as_hexwkb', + 'npoint_as_text', + 'npoint_as_wkb', + 'npoint_from_hexwkb', + 'npoint_from_wkb', + 'npoint_in', + 'npoint_out', + 'nsegment_in', + 'nsegment_out', + 'npoint_make', + 'nsegment_make', + 'geompoint_to_npoint', + 'geom_to_nsegment', + 'npoint_to_geompoint', + 'npoint_to_nsegment', + 'npoint_to_stbox', + 'nsegment_to_geom', + 'nsegment_to_stbox', + 'npoint_hash', + 'npoint_hash_extended', + 'npoint_position', + 'npoint_route', + 'nsegment_end_position', + 'nsegment_route', + 'nsegment_start_position', + 'route_exists', + 'route_geom', + 'route_length', + 'npoint_round', + 'nsegment_round', + 'get_srid_ways', + 'npoint_srid', + 'nsegment_srid', + 'npoint_timestamptz_to_stbox', + 'npoint_tstzspan_to_stbox', + 'npoint_cmp', + 'npoint_eq', + 'npoint_ge', + 'npoint_gt', + 'npoint_le', + 'npoint_lt', + 'npoint_ne', + 'npoint_same', + 'nsegment_cmp', + 'nsegment_eq', + 'nsegment_ge', + 'nsegment_gt', + 'nsegment_le', + 'nsegment_lt', + 'nsegment_ne', + 'npointset_in', + 'npointset_out', + 'npointset_make', + 'npoint_to_set', + 'npointset_end_value', + 'npointset_routes', + 'npointset_start_value', + 'npointset_value_n', + 'npointset_values', + 'contained_npoint_set', + 'contains_set_npoint', + 'intersection_npoint_set', + 'intersection_set_npoint', + 'minus_npoint_set', + 'minus_set_npoint', + 'npoint_union_transfn', + 'union_npoint_set', + 'union_set_npoint', + 'tnpoint_in', + 'tnpoint_out', + 'tnpointinst_make', + 'tgeompoint_to_tnpoint', + 'tnpoint_to_tgeompoint', + 'tnpoint_cumulative_length', + 'tnpoint_length', + 'tnpoint_positions', + 'tnpoint_route', + 'tnpoint_routes', + 'tnpoint_speed', + 'tnpoint_trajectory', + 'tnpoint_twcentroid', + 'tnpoint_at_geom', + 'tnpoint_at_npoint', + 'tnpoint_at_npointset', + 'tnpoint_at_stbox', + 'tnpoint_minus_geom', + 'tnpoint_minus_npoint', + 'tnpoint_minus_npointset', + 'tnpoint_minus_stbox', + 'tdistance_tnpoint_npoint', + 'tdistance_tnpoint_point', + 'tdistance_tnpoint_tnpoint', + 'nad_tnpoint_geo', + 'nad_tnpoint_npoint', + 'nad_tnpoint_stbox', + 'nad_tnpoint_tnpoint', + 'nai_tnpoint_geo', + 'nai_tnpoint_npoint', + 'nai_tnpoint_tnpoint', + 'shortestline_tnpoint_geo', + 'shortestline_tnpoint_npoint', + 'shortestline_tnpoint_tnpoint', + 'tnpoint_tcentroid_transfn', + 'always_eq_npoint_tnpoint', + 'always_eq_tnpoint_npoint', + 'always_eq_tnpoint_tnpoint', + 'always_ne_npoint_tnpoint', + 'always_ne_tnpoint_npoint', + 'always_ne_tnpoint_tnpoint', + 'ever_eq_npoint_tnpoint', + 'ever_eq_tnpoint_npoint', + 'ever_eq_tnpoint_tnpoint', + 'ever_ne_npoint_tnpoint', + 'ever_ne_tnpoint_npoint', + 'ever_ne_tnpoint_tnpoint', + 'teq_tnpoint_npoint', + 'tne_tnpoint_npoint', + ] diff --git a/pymeos_cffi/functions.py b/pymeos_cffi/functions.py index a64c92f..8557f4b 100644 --- a/pymeos_cffi/functions.py +++ b/pymeos_cffi/functions.py @@ -132,235 +132,270 @@ def as_tsequenceset(temporal: Annotated[_ffi.CData, "Temporal *"]) -> Annotated[ return _ffi.cast("TSequenceSet *", temporal) +def float_to_datum(value: float) -> Annotated[_ffi.CData, "Datum"]: + # PostgreSQL's Float8GetDatum reinterprets the 8-byte double as a Datum. + buf = _ffi.new("double[1]", [value]) + return _ffi.cast("Datum *", buf)[0] + + +def int_to_datum(value: int) -> Annotated[_ffi.CData, "Datum"]: + # Int32GetDatum / Int64GetDatum widen the integer to Datum (uintptr_t). + return _ffi.cast("Datum", value) + + +def tbox_expand_float(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_expand_value(box, float_to_datum(d), _lib.T_FLOAT8) + + +def tbox_expand_int(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_expand_value(box, int_to_datum(i), _lib.T_INT4) + + +def tbox_shift_scale_float( + box: Annotated[_ffi.CData, "const TBox *"], + shift: float, + width: float, + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_shift_scale_value( + box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth + ) + + +def tbox_shift_scale_int( + box: Annotated[_ffi.CData, "const TBox *"], + shift: int, + width: int, + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "TBox *"]: + return tbox_shift_scale_value( + box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth + ) + + # ----------------------------------------------------------------------------- # ----------------------End of manually-defined functions---------------------- # ----------------------------------------------------------------------------- -def date_in(string: str) -> Annotated[int, "DateADT"]: - string_converted = string.encode("utf-8") +def date_in(string: str) -> Annotated[int, 'DateADT']: + string_converted = string.encode('utf-8') result = _lib.date_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def date_out(d: int) -> Annotated[str, "char *"]: - d_converted = _ffi.cast("DateADT", d) +def date_out(d: int) -> Annotated[str, 'char *']: + d_converted = _ffi.cast('DateADT', d) result = _lib.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 interval_cmp( - interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[int, "int"]: - interv1_converted = _ffi.cast("const Interval *", interv1) - interv2_converted = _ffi.cast("const Interval *", interv2) +def interval_cmp(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'int']: + interv1_converted = _ffi.cast('const Interval *', interv1) + interv2_converted = _ffi.cast('const Interval *', interv2) result = _lib.interval_cmp(interv1_converted, interv2_converted) _check_error() return result if result != _ffi.NULL else None -def interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, "Interval *"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'Interval *']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.interval_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def interval_out(interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[str, "char *"]: - interv_converted = _ffi.cast("const Interval *", interv) +def interval_out(interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[str, 'char *']: + interv_converted = _ffi.cast('const Interval *', interv) result = _lib.interval_out(interv_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 time_in(string: str, typmod: int) -> Annotated[_ffi.CData, "TimeADT"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def time_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'TimeADT']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.time_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def time_out(t: Annotated[_ffi.CData, "TimeADT"]) -> Annotated[str, "char *"]: - t_converted = _ffi.cast("TimeADT", t) +def time_out(t: Annotated[_ffi.CData, 'TimeADT']) -> Annotated[str, 'char *']: + t_converted = _ffi.cast('TimeADT', t) result = _lib.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 timestamp_in(string: str, typmod: int) -> Annotated[int, "Timestamp"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def timestamp_in(string: str, typmod: int) -> Annotated[int, 'Timestamp']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.timestamp_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def timestamp_out(t: int) -> Annotated[str, "char *"]: - t_converted = _ffi.cast("Timestamp", t) +def timestamp_out(t: int) -> Annotated[str, 'char *']: + t_converted = _ffi.cast('Timestamp', t) result = _lib.timestamp_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 timestamptz_in(string: str, typmod: int) -> Annotated[int, "TimestampTz"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def timestamptz_in(string: str, typmod: int) -> Annotated[int, 'TimestampTz']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.timestamptz_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_out(t: int) -> Annotated[str, "char *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_out(t: int) -> Annotated[str, 'char *']: + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_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 rtree_create_intspan() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_intspan() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_intspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_bigintspan() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_bigintspan() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_bigintspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_floatspan() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_floatspan() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_floatspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_datespan() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_datespan() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_datespan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_tstzspan() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_tstzspan() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_tstzspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_tbox() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_tbox() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_tbox() _check_error() return result if result != _ffi.NULL else None -def rtree_create_stbox() -> Annotated[_ffi.CData, "RTree *"]: +def rtree_create_stbox() -> Annotated[_ffi.CData, 'RTree *']: result = _lib.rtree_create_stbox() _check_error() return result if result != _ffi.NULL else None -def rtree_free(rtree: Annotated[_ffi.CData, "RTree *"]) -> Annotated[None, "void"]: - rtree_converted = _ffi.cast("RTree *", rtree) +def rtree_free(rtree: Annotated[_ffi.CData, 'RTree *']) -> Annotated[None, 'void']: + rtree_converted = _ffi.cast('RTree *', rtree) _lib.rtree_free(rtree_converted) _check_error() -def rtree_insert( - rtree: Annotated[_ffi.CData, "RTree *"], box: Annotated[_ffi.CData, "void *"], id: int -) -> Annotated[None, "void"]: - rtree_converted = _ffi.cast("RTree *", rtree) - box_converted = _ffi.cast("void *", box) - id_converted = _ffi.cast("int64", id) +def rtree_insert(rtree: Annotated[_ffi.CData, 'RTree *'], box: Annotated[_ffi.CData, 'void *'], id: int) -> Annotated[None, 'void']: + rtree_converted = _ffi.cast('RTree *', rtree) + box_converted = _ffi.cast('void *', box) + id_converted = _ffi.cast('int64', id) _lib.rtree_insert(rtree_converted, box_converted, id_converted) _check_error() -def rtree_search( - rtree: Annotated[_ffi.CData, "const RTree *"], - query: Annotated[_ffi.CData, "const void *"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "int *"]: - rtree_converted = _ffi.cast("const RTree *", rtree) - query_converted = _ffi.cast("const void *", query) - count_converted = _ffi.cast("int *", count) - result = _lib.rtree_search(rtree_converted, query_converted, count_converted) +def rtree_search(rtree: Annotated[_ffi.CData, 'const RTree *'], query: Annotated[_ffi.CData, 'const void *']) -> tuple[Annotated[_ffi.CData, 'int *'], Annotated[_ffi.CData, 'int']]: + rtree_converted = _ffi.cast('const RTree *', rtree) + query_converted = _ffi.cast('const void *', query) + count = _ffi.new('int *') + result = _lib.rtree_search(rtree_converted, query_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def meos_errno() -> Annotated[int, "int"]: +def meos_errno() -> Annotated[int, 'int']: result = _lib.meos_errno() _check_error() return result if result != _ffi.NULL else None -def meos_errno_set(err: int) -> Annotated[int, "int"]: +def meos_errno_set(err: int) -> Annotated[int, 'int']: result = _lib.meos_errno_set(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_restore(err: int) -> Annotated[int, "int"]: +def meos_errno_restore(err: int) -> Annotated[int, 'int']: result = _lib.meos_errno_restore(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_reset() -> Annotated[int, "int"]: +def meos_errno_reset() -> Annotated[int, 'int']: result = _lib.meos_errno_reset() _check_error() return result if result != _ffi.NULL else None -def meos_finalize_projsrs() -> Annotated[None, "void"]: +def meos_finalize_projsrs() -> Annotated[None, 'void']: _lib.meos_finalize_projsrs() _check_error() -def meos_finalize_ways() -> Annotated[None, "void"]: +def meos_finalize_ways() -> Annotated[None, 'void']: _lib.meos_finalize_ways() _check_error() -def meos_set_datestyle(newval: str, extra: Annotated[_ffi.CData, "void *"]) -> Annotated[bool, "bool"]: - newval_converted = newval.encode("utf-8") - extra_converted = _ffi.cast("void *", extra) +def meos_set_datestyle(newval: str, extra: Annotated[_ffi.CData, 'void *']) -> Annotated[bool, '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: int | None) -> Annotated[bool, "bool"]: - newval_converted = newval.encode("utf-8") +def meos_set_intervalstyle(newval: str, extra: int | None) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def meos_get_datestyle() -> Annotated[str, "char *"]: +def meos_get_datestyle() -> Annotated[str, 'char *']: 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() -> Annotated[str, "char *"]: +def meos_get_intervalstyle() -> Annotated[str, 'char *']: 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_set_spatial_ref_sys_csv(path: Annotated[_ffi.CData, "const char*"]) -> Annotated[None, "void"]: - path_converted = _ffi.cast("const char*", path) +def meos_set_spatial_ref_sys_csv(path: Annotated[_ffi.CData, 'const char*']) -> Annotated[None, 'void']: + path_converted = _ffi.cast('const char*', path) _lib.meos_set_spatial_ref_sys_csv(path_converted) _check_error() @@ -376,269 +411,257 @@ def meos_initialize(tz_str: str | None) -> None: _lib.meos_initialize() # Check if local spatial ref system csv exists (meaning wheel installation). If it does, use it. - wheel_path = os.path.join(os.path.dirname(__file__), "meos_data", "spatial_ref_sys.csv") + wheel_path = os.path.join( + os.path.dirname(__file__), "meos_data", "spatial_ref_sys.csv" + ) if os.path.exists(wheel_path): _lib.meos_set_spatial_ref_sys_csv(wheel_path.encode("utf-8")) # Timezone is already initialized by meos_initialize, so we only need to set it if tz_str is provided if tz_str is not None: - _lib.meos_initialize_timezone(tz_str.encode("utf-8")) + _lib.meos_initialize_timezone(tz_str.encode('utf-8')) _lib.meos_initialize_error_handler(_lib.py_error_handler) -def meos_finalize() -> Annotated[None, "void"]: +def meos_finalize() -> Annotated[None, 'void']: _lib.meos_finalize() _check_error() -def add_date_int(d: int, days: int) -> Annotated[int, "DateADT"]: - d_converted = _ffi.cast("DateADT", d) - days_converted = _ffi.cast("int32", days) +def add_date_int(d: int, days: int) -> Annotated[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 add_interval_interval( - interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "Interval *"]: - interv1_converted = _ffi.cast("const Interval *", interv1) - interv2_converted = _ffi.cast("const Interval *", interv2) +def add_interval_interval(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 add_timestamptz_interval( - t: int, interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[int, "TimestampTz"]: - t_converted = _ffi.cast("TimestampTz", t) - interv_converted = _ffi.cast("const Interval *", interv) +def add_timestamptz_interval(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, '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() return result if result != _ffi.NULL else None -def bool_in(string: str) -> Annotated[bool, "bool"]: - string_converted = string.encode("utf-8") +def bool_in(string: str) -> Annotated[bool, 'bool']: + string_converted = string.encode('utf-8') result = _lib.bool_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bool_out(b: bool) -> Annotated[str, "char *"]: +def bool_out(b: bool) -> Annotated[str, 'char *']: 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 date_to_timestamp(dateVal: int) -> Annotated[int, "Timestamp"]: - dateVal_converted = _ffi.cast("DateADT", dateVal) +def date_to_timestamp(dateVal: int) -> Annotated[int, 'Timestamp']: + dateVal_converted = _ffi.cast('DateADT', dateVal) result = _lib.date_to_timestamp(dateVal_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_timestamptz(d: int) -> Annotated[int, "TimestampTz"]: - d_converted = _ffi.cast("DateADT", d) +def date_to_timestamptz(d: int) -> Annotated[int, '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 float_exp(d: float) -> Annotated[float, "double"]: +def float_exp(d: float) -> Annotated[float, 'double']: result = _lib.float_exp(d) _check_error() return result if result != _ffi.NULL else None -def float_ln(d: float) -> Annotated[float, "double"]: +def float_ln(d: float) -> Annotated[float, 'double']: result = _lib.float_ln(d) _check_error() return result if result != _ffi.NULL else None -def float_log10(d: float) -> Annotated[float, "double"]: +def float_log10(d: float) -> Annotated[float, 'double']: result = _lib.float_log10(d) _check_error() return result if result != _ffi.NULL else None -def float8_out(d: float, maxdd: int) -> Annotated[str, "char *"]: +def float8_out(d: float, maxdd: int) -> Annotated[str, 'char *']: result = _lib.float8_out(d, 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_round(d: float, maxdd: int) -> Annotated[float, "double"]: +def float_round(d: float, maxdd: int) -> Annotated[float, 'double']: result = _lib.float_round(d, maxdd) _check_error() return result if result != _ffi.NULL else None -def int32_cmp(l: int, r: int) -> Annotated[int, "int"]: - l_converted = _ffi.cast("int32", l) - r_converted = _ffi.cast("int32", r) +def int32_cmp(l: int, r: int) -> Annotated[int, 'int']: + l_converted = _ffi.cast('int32', l) + r_converted = _ffi.cast('int32', r) result = _lib.int32_cmp(l_converted, r_converted) _check_error() return result if result != _ffi.NULL else None -def int64_cmp(l: int, r: int) -> Annotated[int, "int"]: - l_converted = _ffi.cast("int64", l) - r_converted = _ffi.cast("int64", r) +def int64_cmp(l: int, r: int) -> Annotated[int, 'int']: + l_converted = _ffi.cast('int64', l) + r_converted = _ffi.cast('int64', r) result = _lib.int64_cmp(l_converted, r_converted) _check_error() return result if result != _ffi.NULL else None -def interval_make( - years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float -) -> Annotated[_ffi.CData, "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.interval_make( - years_converted, months_converted, weeks_converted, days_converted, hours_converted, mins_converted, secs - ) +def interval_make(years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float) -> Annotated[_ffi.CData, '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.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 minus_date_date(d1: int, d2: int) -> Annotated[int, "int"]: - d1_converted = _ffi.cast("DateADT", d1) - d2_converted = _ffi.cast("DateADT", d2) +def minus_date_date(d1: int, d2: int) -> Annotated[int, 'int']: + 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 minus_date_int(d: int, days: int) -> Annotated[int, "DateADT"]: - d_converted = _ffi.cast("DateADT", d) - days_converted = _ffi.cast("int32", days) +def minus_date_int(d: int, days: int) -> Annotated[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 minus_timestamptz_interval( - t: int, interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[int, "TimestampTz"]: - t_converted = _ffi.cast("TimestampTz", t) - interv_converted = _ffi.cast("const Interval *", interv) +def minus_timestamptz_interval(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, '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 minus_timestamptz_timestamptz(t1: int, t2: int) -> Annotated[_ffi.CData, "Interval *"]: - t1_converted = _ffi.cast("TimestampTz", t1) - t2_converted = _ffi.cast("TimestampTz", t2) +def minus_timestamptz_timestamptz(t1: int, t2: int) -> Annotated[_ffi.CData, '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 mul_interval_double( - interv: Annotated[_ffi.CData, "const Interval *"], factor: float -) -> Annotated[_ffi.CData, "Interval *"]: - interv_converted = _ffi.cast("const Interval *", interv) +def mul_interval_double(interv: Annotated[_ffi.CData, 'const Interval *'], factor: float) -> Annotated[_ffi.CData, 'Interval *']: + interv_converted = _ffi.cast('const Interval *', interv) result = _lib.mul_interval_double(interv_converted, factor) _check_error() return result if result != _ffi.NULL else None -def pg_date_in(string: str) -> Annotated[int, "DateADT"]: - string_converted = string.encode("utf-8") +def pg_date_in(string: str) -> Annotated[int, '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: int) -> Annotated[str, "char *"]: - d_converted = _ffi.cast("DateADT", d) +def pg_date_out(d: int) -> Annotated[str, 'char *']: + 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_interval_cmp( - interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[int, "int"]: - interv1_converted = _ffi.cast("const Interval *", interv1) - interv2_converted = _ffi.cast("const Interval *", interv2) +def pg_interval_cmp(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, '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_interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, "Interval *"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, '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_out(interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[str, "char *"]: - interv_converted = _ffi.cast("const Interval *", interv) +def pg_interval_out(interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[str, 'char *']: + interv_converted = _ffi.cast('const Interval *', interv) result = _lib.pg_interval_out(interv_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) -> Annotated[int, "Timestamp"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_timestamp_in(string: str, typmod: int) -> Annotated[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_out(t: int) -> Annotated[str, "char *"]: - t_converted = _ffi.cast("Timestamp", t) +def pg_timestamp_out(t: int) -> Annotated[str, 'char *']: + t_converted = _ffi.cast('Timestamp', t) result = _lib.pg_timestamp_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_timestamptz_in(string: str, typmod: int) -> Annotated[int, "TimestampTz"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_timestamptz_in(string: str, typmod: int) -> Annotated[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_out(t: int) -> Annotated[str, "char *"]: - t_converted = _ffi.cast("TimestampTz", t) +def pg_timestamptz_out(t: int) -> Annotated[str, 'char *']: + t_converted = _ffi.cast('TimestampTz', t) result = _lib.pg_timestamptz_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 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 -def text_cmp(txt1: str, txt2: str) -> Annotated[int, "int"]: +def text_cmp(txt1: str, txt2: str) -> Annotated[int, 'int']: txt1_converted = cstring2text(txt1) txt2_converted = cstring2text(txt2) result = _lib.text_cmp(txt1_converted, txt2_converted) @@ -646,7 +669,7 @@ def text_cmp(txt1: str, txt2: str) -> Annotated[int, "int"]: return result if result != _ffi.NULL else None -def text_copy(txt: str) -> Annotated[str, "text *"]: +def text_copy(txt: str) -> Annotated[str, 'text *']: txt_converted = cstring2text(txt) result = _lib.text_copy(txt_converted) _check_error() @@ -654,15 +677,15 @@ def text_copy(txt: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None -def text_in(string: str) -> Annotated[str, "text *"]: - string_converted = string.encode("utf-8") +def text_in(string: str) -> Annotated[str, 'text *']: + string_converted = string.encode('utf-8') result = _lib.text_in(string_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def text_initcap(txt: str) -> Annotated[str, "text *"]: +def text_initcap(txt: str) -> Annotated[str, 'text *']: txt_converted = cstring2text(txt) result = _lib.text_initcap(txt_converted) _check_error() @@ -670,7 +693,7 @@ def text_initcap(txt: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None -def text_lower(txt: str) -> Annotated[str, "text *"]: +def text_lower(txt: str) -> Annotated[str, 'text *']: txt_converted = cstring2text(txt) result = _lib.text_lower(txt_converted) _check_error() @@ -678,15 +701,15 @@ def text_lower(txt: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None -def text_out(txt: str) -> Annotated[str, "char *"]: +def text_out(txt: str) -> Annotated[str, 'char *']: 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 text_upper(txt: str) -> Annotated[str, "text *"]: +def text_upper(txt: str) -> Annotated[str, 'text *']: txt_converted = cstring2text(txt) result = _lib.text_upper(txt_converted) _check_error() @@ -694,7 +717,7 @@ def text_upper(txt: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None -def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, "text *"]: +def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, 'text *']: txt1_converted = cstring2text(txt1) txt2_converted = cstring2text(txt2) result = _lib.textcat_text_text(txt1_converted, txt2_converted) @@ -703,734 +726,722 @@ def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, "text *"]: return result if result != _ffi.NULL else None -def timestamptz_shift(t: int, interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[int, "TimestampTz"]: - t_converted = _ffi.cast("TimestampTz", t) - interv_converted = _ffi.cast("const Interval *", interv) +def timestamptz_shift(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'TimestampTz']: + t_converted = _ffi.cast('TimestampTz', t) + interv_converted = _ffi.cast('const Interval *', interv) result = _lib.timestamptz_shift(t_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def timestamp_to_date(t: int) -> Annotated[int, "DateADT"]: - t_converted = _ffi.cast("Timestamp", t) +def timestamp_to_date(t: int) -> Annotated[int, 'DateADT']: + t_converted = _ffi.cast('Timestamp', t) result = _lib.timestamp_to_date(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_date(t: int) -> Annotated[int, "DateADT"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_date(t: int) -> Annotated[int, 'DateADT']: + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_date(t_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def bigintset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def bigintset_out(set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: + 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_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("int64", value) +def bigintspan_expand(s: Annotated[_ffi.CData, 'const Span *'], value: int) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) + value_converted = _ffi.cast('int64', value) result = _lib.bigintspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") +def bigintspan_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def bigintspan_out(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") +def bigintspanset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def dateset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_out(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") +def datespan_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_out(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") +def datespanset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def floatset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def floatset_out(set: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: + 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_expand(s: Annotated[_ffi.CData, "const Span *"], value: float) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_expand(s: Annotated[_ffi.CData, 'const Span *'], value: float) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_expand(s_converted, value) _check_error() return result if result != _ffi.NULL else None -def floatspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") +def floatspan_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_out(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") +def floatspanset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[str, 'char *']: + 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 intset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def intset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def intset_out(set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: + 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_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("int32", value) +def intspan_expand(s: Annotated[_ffi.CData, 'const Span *'], value: int) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) + value_converted = _ffi.cast('int32', value) result = _lib.intspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_in(string: str) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") +def intspan_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_out(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") +def intspanset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: + 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: Annotated[_ffi.CData, "const Set *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_wkb(s: Annotated[_ffi.CData, 'const Set *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_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 return result_converted -def set_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "Set *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def set_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_wkb(s: Annotated[_ffi.CData, 'const Span *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_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 return result_converted -def span_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "Span *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def span_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_wkb(ss: Annotated[_ffi.CData, 'const SpanSet *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_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 return result_converted -def spanset_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "SpanSet *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def spanset_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def textset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def textset_out(set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def tstzset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def tstzset_out(set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") +def tstzspan_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_out(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: + 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) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") +def tstzspanset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: + 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]") -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.new("const int64 []", values) +def bigintset_make(values: 'list[const int64]') -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Span *"]: - lower_converted = _ffi.cast("int64", lower) - upper_converted = _ffi.cast("int64", upper) +def bigintspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, '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]") -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.new("const DateADT []", values) +def dateset_make(values: 'list[const DateADT]') -> Annotated[_ffi.CData, '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: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, "Span *"]: - lower_converted = _ffi.cast("DateADT", lower) - upper_converted = _ffi.cast("DateADT", upper) +def datespan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, '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]") -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.new("const double []", values) +def floatset_make(values: 'list[const double]') -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Span *"]: +def floatspan_make(lower: float, upper: float, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, 'Span *']: result = _lib.floatspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def intset_make(values: "list[const int]") -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.new("const int []", values) +def intset_make(values: 'list[const int]') -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Span *"]: +def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def set_copy(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def span_copy(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_copy(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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[Annotated[_ffi.CData, "Span *"]]) -> Annotated[_ffi.CData, "SpanSet *"]: - spans_converted = _ffi.new("Span []", spans) +def spanset_make(spans: list[Annotated[_ffi.CData, 'Span *']]) -> Annotated[_ffi.CData, 'SpanSet *']: + spans_converted = _ffi.new('Span []', spans) result = _lib.spanset_make(spans_converted, len(spans)) _check_error() return result if result != _ffi.NULL else None -def textset_make(values: list[str]) -> Annotated[_ffi.CData, "Set *"]: +def textset_make(values: list[str]) -> Annotated[_ffi.CData, '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]) -> Annotated[_ffi.CData, "Set *"]: - values_converted = [_ffi.cast("const TimestampTz", x) for x in values] +def tstzset_make(values: list[int]) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: - i_converted = _ffi.cast("int64", i) +def bigint_to_set(i: int) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Span *"]: +def bigint_to_span(i: int) -> Annotated[_ffi.CData, 'Span *']: result = _lib.bigint_to_span(i) _check_error() return result if result != _ffi.NULL else None -def bigint_to_spanset(i: int) -> Annotated[_ffi.CData, "SpanSet *"]: +def bigint_to_spanset(i: int) -> Annotated[_ffi.CData, 'SpanSet *']: result = _lib.bigint_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def date_to_set(d: int) -> Annotated[_ffi.CData, "Set *"]: - d_converted = _ffi.cast("DateADT", d) +def date_to_set(d: int) -> Annotated[_ffi.CData, '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: int) -> Annotated[_ffi.CData, "Span *"]: - d_converted = _ffi.cast("DateADT", d) +def date_to_span(d: int) -> Annotated[_ffi.CData, '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: int) -> Annotated[_ffi.CData, "SpanSet *"]: - d_converted = _ffi.cast("DateADT", d) +def date_to_spanset(d: int) -> Annotated[_ffi.CData, '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 dateset_to_tstzset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_to_tstzset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_to_tstzspan(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_to_tstzspanset(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: +def float_to_set(d: float) -> Annotated[_ffi.CData, 'Set *']: result = _lib.float_to_set(d) _check_error() return result if result != _ffi.NULL else None -def float_to_span(d: float) -> Annotated[_ffi.CData, "Span *"]: +def float_to_span(d: float) -> Annotated[_ffi.CData, 'Span *']: result = _lib.float_to_span(d) _check_error() return result if result != _ffi.NULL else None -def float_to_spanset(d: float) -> Annotated[_ffi.CData, "SpanSet *"]: +def float_to_spanset(d: float) -> Annotated[_ffi.CData, 'SpanSet *']: result = _lib.float_to_spanset(d) _check_error() return result if result != _ffi.NULL else None -def floatset_to_intset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_to_intset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_to_intspan(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_to_intspanset(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 int_to_set(i: int) -> Annotated[_ffi.CData, "Set *"]: +def int_to_set(i: int) -> Annotated[_ffi.CData, 'Set *']: result = _lib.int_to_set(i) _check_error() return result if result != _ffi.NULL else None -def int_to_span(i: int) -> Annotated[_ffi.CData, "Span *"]: +def int_to_span(i: int) -> Annotated[_ffi.CData, 'Span *']: result = _lib.int_to_span(i) _check_error() return result if result != _ffi.NULL else None -def int_to_spanset(i: int) -> Annotated[_ffi.CData, "SpanSet *"]: +def int_to_spanset(i: int) -> Annotated[_ffi.CData, 'SpanSet *']: result = _lib.int_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def intset_to_floatset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intset_to_floatset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_to_floatspan(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_to_floatspanset(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) +def set_to_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 set_to_spanset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Set *", s) +def set_to_spanset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def span_to_spanset(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: +def text_to_set(txt: str) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_set(t: int) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Span *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_span(t: int) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "SpanSet *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_spanset(t: int) -> Annotated[_ffi.CData, '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 tstzset_to_dateset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def tstzset_to_dateset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_to_datespan(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_to_datespanset(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Set *", s) +def bigintset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Set *", s) +def bigintset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "int64"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("int64 *") +def bigintset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, '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: @@ -1438,72 +1449,72 @@ def bigintset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annota return None -def bigintset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "int64 *"]: - s_converted = _ffi.cast("const Set *", s) +def bigintset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Span *", s) +def bigintspan_lower(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Span *", s) +def bigintspan_upper(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 bigintspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Span *", s) +def bigintspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_lower(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 bigintspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[int, "int64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "DateADT"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "DateADT"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "DateADT *"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("DateADT *") +def dateset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, '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: @@ -1511,37 +1522,37 @@ def dateset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotate return None -def dateset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "DateADT *"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Interval *"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_duration(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "DateADT"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_lower(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "DateADT"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_upper(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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_date_n(ss: Annotated[_ffi.CData, "const SpanSet *"], n: int) -> Annotated[_ffi.CData, "DateADT *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - out_result = _ffi.new("DateADT *") +def datespanset_date_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], n: int) -> Annotated[_ffi.CData, '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: @@ -1549,60 +1560,58 @@ def datespanset_date_n(ss: Annotated[_ffi.CData, "const SpanSet *"], n: int) -> return None -def datespanset_dates(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Set *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_dates(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Set *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_dates(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_duration( - ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool -) -> Annotated[_ffi.CData, "Interval *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_duration(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "DateADT"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_end_date(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_num_dates(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "DateADT"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_start_date(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 floatset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "double"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("double *") +def floatset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, '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: @@ -1610,72 +1619,72 @@ def floatset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotat return None -def floatset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "double *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_lower(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_upper(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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 floatspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_lower(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, '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 floatspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[float, '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 intset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) +def intset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) +def intset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "int"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("int *") +def intset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, '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: @@ -1683,196 +1692,196 @@ def intset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated return None -def intset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "int *"]: - s_converted = _ffi.cast("const Set *", s) +def intset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_lower(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_upper(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 intspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_lower(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 intspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "uint32"]: - s_converted = _ffi.cast("const Set *", s) +def set_hash(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], seed: int) -> Annotated[int, "uint64"]: - s_converted = _ffi.cast("const Set *", s) - seed_converted = _ffi.cast("uint64", seed) +def set_hash_extended(s: Annotated[_ffi.CData, 'const Set *'], seed: int) -> Annotated[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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) +def set_num_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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 span_hash(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "uint32"]: - s_converted = _ffi.cast("const Span *", s) +def span_hash(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"], seed: int) -> Annotated[int, "uint64"]: - s_converted = _ffi.cast("const Span *", s) - seed_converted = _ffi.cast("uint64", seed) +def span_hash_extended(s: Annotated[_ffi.CData, 'const Span *'], seed: int) -> Annotated[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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def span_lower_inc(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def span_upper_inc(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 spanset_end_span(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_end_span(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "uint32"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_hash(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"], seed: int) -> Annotated[int, "uint64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - seed_converted = _ffi.cast("uint64", seed) +def spanset_hash_extended(ss: Annotated[_ffi.CData, 'const SpanSet *'], seed: int) -> Annotated[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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_lower_inc(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_num_spans(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_span_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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_spanarr(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span **"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_spanarr(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span **']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_spanarr(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_start_span(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_start_span(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_upper_inc(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 textset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "text *"]: - s_converted = _ffi.cast("const Set *", s) +def textset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'text *']: + 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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "text *"]: - s_converted = _ffi.cast("const Set *", s) +def textset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'text *']: + 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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "text **"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("text **") +def textset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, '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: @@ -1880,30 +1889,30 @@ def textset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotate return None -def textset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "text **"]: - s_converted = _ffi.cast("const Set *", s) +def textset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "TimestampTz"]: - s_converted = _ffi.cast("const Set *", s) +def tstzset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "TimestampTz"]: - s_converted = _ffi.cast("const Set *", s) +def tstzset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> int: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("TimestampTz *") +def tstzset_value_n(s: Annotated[_ffi.CData, '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: @@ -1911,81 +1920,79 @@ def tstzset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> int: return None -def tstzset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "TimestampTz *"]: - s_converted = _ffi.cast("const Set *", s) +def tstzset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Interval *"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_duration(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "TimestampTz"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_lower(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "TimestampTz"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_upper(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool -) -> Annotated[_ffi.CData, "Interval *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_duration(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_end_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_lower(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_num_timestamps(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_start_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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_timestamps(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Set *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_timestamps(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Set *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_timestamps(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, "const SpanSet *"], n: int) -> int: - ss_converted = _ffi.cast("const SpanSet *", ss) - out_result = _ffi.new("TimestampTz *") +def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, '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: @@ -1993,3984 +2000,3666 @@ def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, "const SpanSet *"], n: i return None -def tstzspanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) +def bigintset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) +def bigintspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) +def bigintspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def dateset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 datespan_shift_scale( - s: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def datespan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 datespanset_shift_scale( - ss: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 floatset_ceil(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_ceil(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_ceil(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_degrees(s: Annotated[_ffi.CData, "const Set *"], normalize: bool) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_degrees(s: Annotated[_ffi.CData, 'const Set *'], normalize: bool) -> Annotated[_ffi.CData, '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_floor(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_floor(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_floor(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_radians(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_radians(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_shift_scale( - s: Annotated[_ffi.CData, "const Set *"], shift: float, width: float, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def floatset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 floatspan_ceil(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_ceil(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_ceil(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_degrees(s: Annotated[_ffi.CData, "const Span *"], normalize: bool) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_degrees(s: Annotated[_ffi.CData, 'const Span *'], normalize: bool) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_degrees(s_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def floatspan_floor(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_floor(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_floor(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_radians(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_radians(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_radians(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_round(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_round(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], shift: float, width: float, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def floatspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 floatspanset_ceil(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_ceil(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_ceil(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_floor(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_floor(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_floor(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_degrees( - ss: Annotated[_ffi.CData, "const SpanSet *"], normalize: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_degrees(ss: Annotated[_ffi.CData, 'const SpanSet *'], normalize: bool) -> Annotated[_ffi.CData, 'SpanSet *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_degrees(ss_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def floatspanset_radians(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_radians(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_radians(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_round(ss: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_round(ss: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], shift: float, width: float, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 intset_shift_scale( - s: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 intspan_shift_scale( - s: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def intspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 intspanset_shift_scale( - ss: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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 tstzspan_expand( - s: Annotated[_ffi.CData, "const Span *"], interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - interv_converted = _ffi.cast("const Interval *", interv) +def tstzspan_expand(s: Annotated[_ffi.CData, 'const Span *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) + interv_converted = _ffi.cast('const Interval *', interv) result = _lib.tstzspan_expand(s_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def set_round(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def set_round(s: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.set_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def textcat_text_textset(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: +def textcat_text_textset(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + 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 textcat_textset_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def textcat_textset_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, '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 textset_initcap(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def textset_initcap(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def textset_lower(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def textset_upper(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[int, "TimestampTz"]: - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def timestamptz_tprecision(t: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[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: Annotated[_ffi.CData, "const Set *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 tstzset_tprecision( - s: Annotated[_ffi.CData, "const Set *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def tstzset_tprecision(s: Annotated[_ffi.CData, 'const Set *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, '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 tstzspan_shift_scale( - s: Annotated[_ffi.CData, "const Span *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def tstzspan_tprecision(s: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, '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 tstzspanset_shift_scale( - ss: Annotated[_ffi.CData, "const SpanSet *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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 +def tstzspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def tstzspanset_tprecision(ss: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, '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 set_cmp( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_cmp(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_eq(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_ge(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_gt(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_le(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_lt(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_ne(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_cmp(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_eq(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_ge(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_gt(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_le(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_lt(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_ne(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[int, "int"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_cmp(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_eq(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_ge(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_gt(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_le(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_lt(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_ne(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 set_spans(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) +def set_spans(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.set_spans(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_split_each_n_spans( - s: Annotated[_ffi.CData, "const Set *"], elems_per_span: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) - count_converted = _ffi.cast("int *", count) - result = _lib.set_split_each_n_spans(s_converted, elems_per_span, count_converted) +def set_split_each_n_spans(s: Annotated[_ffi.CData, 'const Set *'], elems_per_span: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Set *', s) + count = _ffi.new('int *') + result = _lib.set_split_each_n_spans(s_converted, elems_per_span, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def set_split_n_spans( - s: Annotated[_ffi.CData, "const Set *"], span_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) - count_converted = _ffi.cast("int *", count) - result = _lib.set_split_n_spans(s_converted, span_count, count_converted) +def set_split_n_spans(s: Annotated[_ffi.CData, 'const Set *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Set *', s) + count = _ffi.new('int *') + result = _lib.set_split_n_spans(s_converted, span_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def spanset_spans(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_spans(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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_split_each_n_spans( - ss: Annotated[_ffi.CData, "const SpanSet *"], elems_per_span: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.spanset_split_each_n_spans(ss_converted, elems_per_span, count_converted) +def spanset_split_each_n_spans(ss: Annotated[_ffi.CData, 'const SpanSet *'], elems_per_span: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') + result = _lib.spanset_split_each_n_spans(ss_converted, elems_per_span, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def spanset_split_n_spans( - ss: Annotated[_ffi.CData, "const SpanSet *"], span_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.spanset_split_n_spans(ss_converted, span_count, count_converted) +def spanset_split_n_spans(ss: Annotated[_ffi.CData, 'const SpanSet *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') + result = _lib.spanset_split_n_spans(ss_converted, span_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def adjacent_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def adjacent_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def adjacent_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def adjacent_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def adjacent_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def adjacent_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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_spanset( - s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 adjacent_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def adjacent_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def adjacent_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def adjacent_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def adjacent_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def adjacent_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def adjacent_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def contained_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def contained_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def contained_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def contained_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def contained_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def contained_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def contained_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def contained_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contained_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def contained_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def contained_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def contained_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: +def contained_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def contained_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def contained_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def contains_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def contains_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def contains_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, '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_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def contains_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contains_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: str) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def contains_set_text(s: Annotated[_ffi.CData, 'const Set *'], t: str) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def contains_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def contains_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def contains_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def contains_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def contains_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def contains_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def contains_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def contains_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def contains_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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 contains_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def contains_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def contains_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def contains_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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 overlaps_set_set( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overlaps_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overlaps_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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_span_spanset( - s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overlaps_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 overlaps_spanset_span( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overlaps_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overlaps_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def after_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def after_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def after_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def after_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def after_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def after_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def after_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def after_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def after_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def after_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def after_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def after_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def before_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def before_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def before_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def before_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def before_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def before_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def before_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def before_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def before_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def before_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def before_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def before_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def left_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def left_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def left_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def left_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def left_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def left_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def left_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def left_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def left_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def left_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def left_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def left_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def left_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def left_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def left_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def left_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def left_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def left_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: +def left_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def overafter_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 overafter_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def overafter_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 overafter_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overafter_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 overafter_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def overafter_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, '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_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def overafter_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def overafter_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def overafter_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def overafter_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overafter_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def overbefore_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 overbefore_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def overbefore_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 overbefore_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overbefore_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 overbefore_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def overbefore_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, '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_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def overbefore_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, '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_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, '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_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def overbefore_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, '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_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, '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_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def overbefore_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def overbefore_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overbefore_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def overleft_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def overleft_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overleft_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overleft_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overleft_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overleft_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def overleft_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overleft_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overleft_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overleft_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overleft_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def overleft_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overleft_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overleft_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overleft_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def overleft_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overleft_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overleft_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: +def overleft_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def overright_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def overright_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overright_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overright_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overright_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overright_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def overright_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overright_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overright_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overright_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def overright_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def overright_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overright_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def overright_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overright_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def overright_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overright_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overright_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: +def overright_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def right_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def right_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def right_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def right_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def right_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def right_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def right_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def right_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def right_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def right_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) +def right_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def right_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def right_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) +def right_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def right_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def right_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def right_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def right_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "bool"]: +def right_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 intersection_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def intersection_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 intersection_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def intersection_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + d_converted = _ffi.cast('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 intersection_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intersection_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 intersection_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intersection_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 intersection_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def intersection_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def intersection_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intersection_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, '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_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intersection_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def intersection_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def intersection_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def intersection_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def intersection_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def intersection_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) +def intersection_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Span *"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def intersection_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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_span_spanset( - s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 intersection_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, '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_spanset_bigint( - ss: Annotated[_ffi.CData, "const SpanSet *"], i: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def intersection_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def intersection_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def intersection_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def intersection_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, '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 intersection_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: +def intersection_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + 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 intersection_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def intersection_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + t_converted = _ffi.cast('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 minus_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def minus_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def minus_bigint_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def minus_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def minus_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def minus_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def minus_float_span(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_float_spanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def minus_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def minus_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_int_spanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def minus_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def minus_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def minus_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, '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_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def minus_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def minus_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def minus_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def minus_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def minus_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def minus_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def minus_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def minus_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def minus_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def minus_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def minus_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def minus_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def minus_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def minus_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def minus_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: +def minus_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def minus_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 minus_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def minus_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 union_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def union_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 union_bigint_span(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def union_bigint_span(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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 union_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("SpanSet *", ss) +def union_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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 union_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def union_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + d_converted = _ffi.cast('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 union_date_span(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def union_date_span(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, '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 union_date_spanset(d: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("SpanSet *", ss) +def union_date_spanset(d: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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 union_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def union_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 union_float_span(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def union_float_span(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, '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 union_float_spanset(d: float, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("SpanSet *", ss) +def union_float_spanset(d: float, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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 union_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def union_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 union_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def union_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 union_int_spanset(i: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("SpanSet *", ss) +def union_int_spanset(i: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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 union_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def union_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def union_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def union_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, '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_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def union_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def union_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def union_set_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def union_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def union_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def union_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def union_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) +def union_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def union_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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_spanset( - s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 union_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def union_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def union_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def union_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def union_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def union_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], t: int -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def union_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, '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 union_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: +def union_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + 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 union_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def union_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + t_converted = _ffi.cast('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 union_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def union_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 union_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("SpanSet *", ss) +def union_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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 distance_bigintset_bigintset( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[int, "int64"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_bigintset_bigintset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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 distance_bigintspan_bigintspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int64"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_bigintspan_bigintspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_bigintspanset_bigintspan( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_bigintspanset_bigintspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_bigintspanset_bigintspanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[int, "int64"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_bigintspanset_bigintspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 distance_dateset_dateset( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_dateset_dateset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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 distance_datespan_datespan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_datespan_datespan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_datespanset_datespan( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_datespanset_datespan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_datespanset_datespanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[int, "int"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_datespanset_datespanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 distance_floatset_floatset( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[float, "double"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_floatset_floatset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, '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 distance_floatspan_floatspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[float, "double"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_floatspan_floatspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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 distance_floatspanset_floatspan( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_floatspanset_floatspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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 distance_floatspanset_floatspanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[float, "double"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_floatspanset_floatspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, '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 distance_intset_intset( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_intset_intset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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 distance_intspan_intspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_intspan_intspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_intspanset_intspan( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_intspanset_intspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, '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 distance_intspanset_intspanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[int, "int"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_intspanset_intspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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 distance_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def distance_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[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 distance_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def distance_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[int, '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 distance_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Set *", s) +def distance_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[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: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) +def distance_set_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[int, 'int']: + 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_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def distance_set_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[float, '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_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[int, "int64"]: - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def distance_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[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 distance_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def distance_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[int, '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 distance_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Span *", s) +def distance_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[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: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Span *", s) +def distance_span_int(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[int, 'int']: + 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_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[float, "double"]: - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def distance_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[float, '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_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[int, "int64"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def distance_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[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() return result if result != _ffi.NULL else None -def distance_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def distance_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[int, '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() return result if result != _ffi.NULL else None -def distance_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def distance_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[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: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def distance_spanset_int(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[int, 'int']: + 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: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def distance_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[float, '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_tstzset_tstzset( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[float, "double"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_tstzset_tstzset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, '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 distance_tstzspan_tstzspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[float, "double"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_tstzspan_tstzspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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 distance_tstzspanset_tstzspan( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_tstzspanset_tstzspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, '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 distance_tstzspanset_tstzspanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[float, "double"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_tstzspanset_tstzspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, '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 bigint_extent_transfn(state: Annotated[_ffi.CData, "Span *"], i: int) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - i_converted = _ffi.cast("int64", i) +def bigint_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], i: int) -> Annotated[_ffi.CData, '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 bigint_union_transfn(state: Annotated[_ffi.CData, "Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - i_converted = _ffi.cast("int64", i) +def bigint_union_transfn(state: Annotated[_ffi.CData, 'Set *'], i: int) -> Annotated[_ffi.CData, '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 date_extent_transfn(state: Annotated[_ffi.CData, "Span *"], d: int) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - d_converted = _ffi.cast("DateADT", d) +def date_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], d: int) -> Annotated[_ffi.CData, '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 date_union_transfn(state: Annotated[_ffi.CData, "Set *"], d: int) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - d_converted = _ffi.cast("DateADT", d) +def date_union_transfn(state: Annotated[_ffi.CData, 'Set *'], d: int) -> Annotated[_ffi.CData, '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 float_extent_transfn(state: Annotated[_ffi.CData, "Span *"], d: float) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) +def float_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], d: float) -> Annotated[_ffi.CData, '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 float_union_transfn(state: Annotated[_ffi.CData, "Set *"], d: float) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) +def float_union_transfn(state: Annotated[_ffi.CData, 'Set *'], d: float) -> Annotated[_ffi.CData, '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(state: Annotated[_ffi.CData, "Span *"], i: int) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) +def int_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], i: int) -> Annotated[_ffi.CData, '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 int_union_transfn(state: Annotated[_ffi.CData, "Set *"], i: int) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - i_converted = _ffi.cast("int32", i) +def int_union_transfn(state: Annotated[_ffi.CData, 'Set *'], i: int) -> Annotated[_ffi.CData, '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 set_extent_transfn( - state: Annotated[_ffi.CData, "Span *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - s_converted = _ffi.cast("const Set *", s) +def set_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 set_union_finalfn(state: Annotated[_ffi.CData, "Set *"]) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) +def set_union_finalfn(state: Annotated[_ffi.CData, 'Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Set *"], s: Annotated[_ffi.CData, "Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - s_converted = _ffi.cast("Set *", s) +def set_union_transfn(state: Annotated[_ffi.CData, 'Set *'], s: Annotated[_ffi.CData, 'Set *']) -> Annotated[_ffi.CData, '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 span_extent_transfn( - state: Annotated[_ffi.CData, "Span *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - s_converted = _ffi.cast("const Span *", s) +def span_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 span_union_transfn( - state: Annotated[_ffi.CData, "SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - state_converted = _ffi.cast("SpanSet *", state) - s_converted = _ffi.cast("const Span *", s) +def span_union_transfn(state: Annotated[_ffi.CData, 'SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 spanset_extent_transfn( - state: Annotated[_ffi.CData, "Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 spanset_union_finalfn(state: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - state_converted = _ffi.cast("SpanSet *", state) +def spanset_union_finalfn(state: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SpanSet *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - state_converted = _ffi.cast("SpanSet *", state) - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_union_transfn(state: Annotated[_ffi.CData, 'SpanSet *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Set *"], txt: str) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) +def text_union_transfn(state: Annotated[_ffi.CData, 'Set *'], txt: str) -> Annotated[_ffi.CData, '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(state: Annotated[_ffi.CData, "Span *"], t: int) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], t: int) -> Annotated[_ffi.CData, '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 timestamptz_union_transfn(state: Annotated[_ffi.CData, "Set *"], t: int) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_union_transfn(state: Annotated[_ffi.CData, 'Set *'], t: int) -> Annotated[_ffi.CData, '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 bigint_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, "int64"]: - value_converted = _ffi.cast("int64", value) - vsize_converted = _ffi.cast("int64", vsize) - vorigin_converted = _ffi.cast("int64", vorigin) +def bigint_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, 'int64']: + value_converted = _ffi.cast('int64', value) + vsize_converted = _ffi.cast('int64', vsize) + vorigin_converted = _ffi.cast('int64', vorigin) result = _lib.bigint_get_bin(value_converted, vsize_converted, vorigin_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_bins( - s: Annotated[_ffi.CData, "const Span *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - vsize_converted = _ffi.cast("int64", vsize) - vorigin_converted = _ffi.cast("int64", vorigin) - count_converted = _ffi.cast("int *", count) - result = _lib.bigintspan_bins(s_converted, vsize_converted, vorigin_converted, count_converted) +def bigintspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + vsize_converted = _ffi.cast('int64', vsize) + vorigin_converted = _ffi.cast('int64', vorigin) + count = _ffi.new('int *') + result = _lib.bigintspan_bins(s_converted, vsize_converted, vorigin_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def bigintspanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - vsize_converted = _ffi.cast("int64", vsize) - vorigin_converted = _ffi.cast("int64", vorigin) - count_converted = _ffi.cast("int *", count) - result = _lib.bigintspanset_bins(ss_converted, vsize_converted, vorigin_converted, count_converted) +def bigintspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + vsize_converted = _ffi.cast('int64', vsize) + vorigin_converted = _ffi.cast('int64', vorigin) + count = _ffi.new('int *') + result = _lib.bigintspanset_bins(ss_converted, vsize_converted, vorigin_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def date_get_bin( - d: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[int, "DateADT"]: - d_converted = _ffi.cast("DateADT", d) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("DateADT", torigin) +def date_get_bin(d: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[int, 'DateADT']: + d_converted = _ffi.cast('DateADT', d) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('DateADT', torigin) result = _lib.date_get_bin(d_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_bins( - s: Annotated[_ffi.CData, "const Span *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("DateADT", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.datespan_bins(s_converted, duration_converted, torigin_converted, count_converted) +def datespan_bins(s: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('DateADT', torigin) + count = _ffi.new('int *') + result = _lib.datespan_bins(s_converted, duration_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 datespanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("DateADT", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.datespanset_bins(ss_converted, duration_converted, torigin_converted, count_converted) +def datespanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('DateADT', torigin) + count = _ffi.new('int *') + result = _lib.datespanset_bins(ss_converted, duration_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 float_get_bin(value: float, vsize: float, vorigin: float) -> Annotated[float, "double"]: +def float_get_bin(value: float, vsize: float, vorigin: float) -> Annotated[float, 'double']: result = _lib.float_get_bin(value, vsize, vorigin) _check_error() return result if result != _ffi.NULL else None -def floatspan_bins( - s: Annotated[_ffi.CData, "const Span *"], vsize: float, vorigin: float, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - count_converted = _ffi.cast("int *", count) - result = _lib.floatspan_bins(s_converted, vsize, vorigin, count_converted) +def floatspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + count = _ffi.new('int *') + result = _lib.floatspan_bins(s_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def floatspanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: float, vorigin: float, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.floatspanset_bins(ss_converted, vsize, vorigin, count_converted) +def floatspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') + result = _lib.floatspanset_bins(ss_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def int_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, "int"]: +def int_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, 'int']: result = _lib.int_get_bin(value, vsize, vorigin) _check_error() return result if result != _ffi.NULL else None -def intspan_bins( - s: Annotated[_ffi.CData, "const Span *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - count_converted = _ffi.cast("int *", count) - result = _lib.intspan_bins(s_converted, vsize, vorigin, count_converted) +def intspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + count = _ffi.new('int *') + result = _lib.intspan_bins(s_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def intspanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.intspanset_bins(ss_converted, vsize, vorigin, count_converted) +def intspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') + result = _lib.intspanset_bins(ss_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def timestamptz_get_bin( - t: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[int, "TimestampTz"]: - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def timestamptz_get_bin(t: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[int, 'TimestampTz']: + t_converted = _ffi.cast('TimestampTz', t) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) result = _lib.timestamptz_get_bin(t_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_bins( - s: Annotated[_ffi.CData, "const Span *"], - duration: Annotated[_ffi.CData, "const Interval *"], - origin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) - count_converted = _ffi.cast("int *", count) - result = _lib.tstzspan_bins(s_converted, duration_converted, origin_converted, count_converted) +def tstzspan_bins(s: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) + count = _ffi.new('int *') + result = _lib.tstzspan_bins(s_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 tstzspanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tstzspanset_bins(ss_converted, duration_converted, torigin_converted, count_converted) +def tstzspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tstzspanset_bins(ss_converted, duration_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 tbox_as_hexwkb( - box: Annotated[_ffi.CData, "const TBox *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TBox *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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 tbox_as_wkb( - box: Annotated[_ffi.CData, "const TBox *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: - 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: Annotated[_ffi.CData, 'const TBox *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: + 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 return result_converted -def tbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "TBox *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def tbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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_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_in(string: str) -> Annotated[_ffi.CData, "TBox *"]: - string_converted = string.encode("utf-8") +def tbox_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[str, "char *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_out(box: Annotated[_ffi.CData, 'const TBox *'], maxdd: int) -> Annotated[str, 'char *']: + 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 float_timestamptz_to_tbox(d: float, t: int) -> Annotated[_ffi.CData, "TBox *"]: - t_converted = _ffi.cast("TimestampTz", t) +def float_timestamptz_to_tbox(d: float, t: int) -> Annotated[_ffi.CData, '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 float_tstzspan_to_tbox(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "TBox *"]: - s_converted = _ffi.cast("const Span *", s) +def float_tstzspan_to_tbox(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 int_timestamptz_to_tbox(i: int, t: int) -> Annotated[_ffi.CData, "TBox *"]: - t_converted = _ffi.cast("TimestampTz", t) +def int_timestamptz_to_tbox(i: int, t: int) -> Annotated[_ffi.CData, '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 int_tstzspan_to_tbox(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "TBox *"]: - s_converted = _ffi.cast("const Span *", s) +def int_tstzspan_to_tbox(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 numspan_tstzspan_to_tbox( - span: Annotated[_ffi.CData, "const Span *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "TBox *"]: - span_converted = _ffi.cast("const Span *", span) - s_converted = _ffi.cast("const Span *", s) +def numspan_tstzspan_to_tbox(span: Annotated[_ffi.CData, 'const Span *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "TBox *"]: - span_converted = _ffi.cast("const Span *", span) - t_converted = _ffi.cast("TimestampTz", t) +def numspan_timestamptz_to_tbox(span: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, '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 tbox_copy(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_copy(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"] | None, p: Annotated[_ffi.CData, "const Span *"] | None -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'] | None, p: Annotated[_ffi.CData, 'const Span *'] | None) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "TBox *"]: +def float_to_tbox(d: float) -> Annotated[_ffi.CData, 'TBox *']: result = _lib.float_to_tbox(d) _check_error() return result if result != _ffi.NULL else None -def int_to_tbox(i: int) -> Annotated[_ffi.CData, "TBox *"]: +def int_to_tbox(i: int) -> Annotated[_ffi.CData, 'TBox *']: result = _lib.int_to_tbox(i) _check_error() return result if result != _ffi.NULL else None -def set_to_tbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "TBox *"]: - s_converted = _ffi.cast("const Set *", s) +def set_to_tbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "TBox *"]: - s_converted = _ffi.cast("const Span *", s) +def span_to_tbox(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "TBox *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_to_tbox(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 tbox_to_intspan(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "Span *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_intspan(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "Span *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_floatspan(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "Span *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_tstzspan(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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_tbox(t: int) -> Annotated[_ffi.CData, "TBox *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_tbox(t: int) -> Annotated[_ffi.CData, '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 tbox_hash(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[int, "uint32"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_hash(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'uint32']: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_hash(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hash_extended(box: Annotated[_ffi.CData, "const TBox *"], seed: int) -> Annotated[int, "uint64"]: - box_converted = _ffi.cast("const TBox *", box) - seed_converted = _ffi.cast("uint64", seed) +def tbox_hash_extended(box: Annotated[_ffi.CData, 'const TBox *'], seed: int) -> Annotated[int, 'uint64']: + box_converted = _ffi.cast('const TBox *', box) + seed_converted = _ffi.cast('uint64', seed) result = _lib.tbox_hash_extended(box_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hast(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_hast(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_hasx(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TBox *"]) -> int: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("TimestampTz *") +def tbox_tmax(box: Annotated[_ffi.CData, '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: @@ -5978,9 +5667,9 @@ def tbox_tmax(box: Annotated[_ffi.CData, "const TBox *"]) -> int: return None -def tbox_tmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_tmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -5988,9 +5677,9 @@ def tbox_tmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi. return None -def tbox_tmin(box: Annotated[_ffi.CData, "const TBox *"]) -> int: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("TimestampTz *") +def tbox_tmin(box: Annotated[_ffi.CData, '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: @@ -5998,9 +5687,9 @@ def tbox_tmin(box: Annotated[_ffi.CData, "const TBox *"]) -> int: return None -def tbox_tmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_tmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6008,9 +5697,9 @@ def tbox_tmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi. return None -def tbox_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tbox_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6018,9 +5707,9 @@ def tbox_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CDat return None -def tbox_xmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_xmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6028,9 +5717,9 @@ def tbox_xmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi. return None -def tbox_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tbox_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6038,9 +5727,9 @@ def tbox_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CDat return None -def tbox_xmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_xmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6048,9 +5737,9 @@ def tbox_xmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi. return None -def tboxfloat_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tboxfloat_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6058,9 +5747,9 @@ def tboxfloat_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi return None -def tboxfloat_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tboxfloat_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6068,9 +5757,9 @@ def tboxfloat_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi return None -def tboxint_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "int"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("int *") +def tboxint_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6078,9 +5767,9 @@ def tboxint_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.C return None -def tboxint_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "int"]: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("int *") +def tboxint_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -6088,702 +5777,598 @@ def tboxint_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.C return None -def tbox_expand_time( - box: Annotated[_ffi.CData, "const TBox *"], interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - interv_converted = _ffi.cast("const Interval *", interv) +def tbox_expand_time(box: Annotated[_ffi.CData, 'const TBox *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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_round(box: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tbox_round(box: Annotated[_ffi.CData, 'const TBox *'], maxdd: int) -> Annotated[_ffi.CData, '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_time( - box: Annotated[_ffi.CData, "const TBox *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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 +def tbox_shift_scale_time(box: Annotated[_ffi.CData, 'const TBox *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 tfloatbox_expand(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tfloatbox_expand(box: Annotated[_ffi.CData, 'const TBox *'], d: float) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tfloatbox_expand(box_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloatbox_shift_scale( - box: Annotated[_ffi.CData, "const TBox *"], shift: float, width: float, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tfloatbox_shift_scale(box: Annotated[_ffi.CData, 'const TBox *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tfloatbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tintbox_expand(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tintbox_expand(box: Annotated[_ffi.CData, 'const TBox *'], i: int) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tintbox_expand(box_converted, i) _check_error() return result if result != _ffi.NULL else None -def tintbox_shift_scale( - box: Annotated[_ffi.CData, "const TBox *"], shift: int, width: int, hasshift: bool, haswidth: bool -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) +def tintbox_shift_scale(box: Annotated[_ffi.CData, 'const TBox *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tintbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def union_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"], strict: bool -) -> Annotated[_ffi.CData, "TBox *"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def union_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *'], strict: bool) -> Annotated[_ffi.CData, '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 intersection_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[_ffi.CData, "TBox *"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def intersection_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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 adjacent_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def adjacent_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 contained_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def contained_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 contains_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def contains_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 overlaps_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overlaps_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def same_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 after_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def after_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 before_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def before_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 left_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def left_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 overafter_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overafter_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 overbefore_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overbefore_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 overleft_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overleft_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 overright_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overright_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 right_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def right_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 tbox_cmp( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[int, "int"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_cmp(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, '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_eq( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_eq(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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_ge( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_ge(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_gt(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 tbox_le( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_le(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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_lt( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_lt(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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_ne( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_ne(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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 tbool_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tbool_from_mfjson(string: str) -> Annotated[_ffi.CData, '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 tbool_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tbool_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_out(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: + 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: Annotated[_ffi.CData, "const Temporal *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], with_bbox: bool, flags: int, precision: int, srs: str | None -) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL +def temporal_as_mfjson(temp: Annotated[_ffi.CData, 'const Temporal *'], with_bbox: bool, flags: int, precision: int, srs: str | None) -> Annotated[str, 'char *']: + 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: Annotated[_ffi.CData, "const Temporal *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_wkb(temp: Annotated[_ffi.CData, 'const Temporal *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_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_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "Temporal *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def temporal_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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_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_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tfloat_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tfloat_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tfloat_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + 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 tint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tint_from_mfjson(string: str) -> Annotated[_ffi.CData, '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 tint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tint_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_out(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: + 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 ttext_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def ttext_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.ttext_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def ttext_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_out(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: + 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 tbool_from_base_temp( - b: bool, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_from_base_temp(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "TInstant *"]: - t_converted = _ffi.cast("TimestampTz", t) +def tboolinst_make(b: bool, t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Set *", s) +def tboolseq_from_base_tstzset(b: bool, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Span *", s) +def tboolseq_from_base_tstzspan(b: bool, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tboolseqset_from_base_tstzspanset(b: bool, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_copy(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_from_base_temp(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "TInstant *"]: - t_converted = _ffi.cast("TimestampTz", t) +def tfloatinst_make(d: float, t: int) -> Annotated[_ffi.CData, '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_tstzset( - d: float, s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Set *", s) +def tfloatseq_from_base_tstzset(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 tfloatseq_from_base_tstzspan( - d: float, s: Annotated[_ffi.CData, "const Span *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Span *", s) +def tfloatseq_from_base_tstzspan(d: float, s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + s_converted = _ffi.cast('const Span *', s) result = _lib.tfloatseq_from_base_tstzspan(d, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_from_base_tstzspanset( - d: float, ss: Annotated[_ffi.CData, "const SpanSet *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tfloatseqset_from_base_tstzspanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tfloatseqset_from_base_tstzspanset(d, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tint_from_base_temp(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_from_base_temp(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "TInstant *"]: - t_converted = _ffi.cast("TimestampTz", t) +def tintinst_make(i: int, t: int) -> Annotated[_ffi.CData, '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_tstzset(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Set *", s) +def tintseq_from_base_tstzset(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 tintseq_from_base_tstzspan( - i: int, s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - s_converted = _ffi.cast("const Span *", s) +def tintseq_from_base_tstzspan(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 tintseqset_from_base_tstzspanset( - i: int, ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tintseqset_from_base_tstzspanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 tsequence_make( - instants: Annotated[list, "TInstant **"], - count: int, - lower_inc: bool, - upper_inc: bool, - interp: InterpolationType, - normalize: bool, -) -> Annotated[_ffi.CData, "TSequence *"]: - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] +def tsequence_make(instants: Annotated[list, 'TInstant **'], count: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: + instants_converted = [_ffi.cast('TInstant *', x) for x in instants] result = _lib.tsequence_make(instants_converted, count, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make( - sequences: Annotated[list, "TSequence **"], count: int, normalize: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] +def tsequenceset_make(sequences: Annotated[list, 'TSequence **'], count: int, normalize: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + sequences_converted = [_ffi.cast('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: Annotated[list, "TInstant **"], - interp: InterpolationType, - maxt: Annotated[_ffi.CData, "const Interval *"] | None, - maxdist: float, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] - maxt_converted = _ffi.cast("const Interval *", maxt) if maxt is not None else _ffi.NULL +def tsequenceset_make_gaps(instants: Annotated[list, 'TInstant **'], interp: InterpolationType, maxt: Annotated[_ffi.CData, 'const Interval *'] | None, maxdist: float) -> Annotated[_ffi.CData, 'TSequenceSet *']: + instants_converted = [_ffi.cast('TInstant *', x) for x in instants] + maxt_converted = _ffi.cast('const Interval *', maxt) if maxt is not None else _ffi.NULL result = _lib.tsequenceset_make_gaps(instants_converted, len(instants), interp, maxt_converted, maxdist) _check_error() return result if result != _ffi.NULL else None -def ttext_from_base_temp( - txt: str, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: +def ttext_from_base_temp(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "TInstant *"]: +def ttextinst_make(txt: str, t: int) -> Annotated[_ffi.CData, '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_tstzset( - txt: str, s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequence *"]: +def ttextseq_from_base_tstzset(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 ttextseq_from_base_tstzspan( - txt: str, s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "TSequence *"]: +def ttextseq_from_base_tstzspan(txt: str, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 ttextseqset_from_base_tstzspanset( - txt: str, ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: +def ttextseqset_from_base_tstzspanset(txt: str, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 tbool_to_tint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_to_tint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_to_tint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tstzspan(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_to_tint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_to_tfloat(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_to_span(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tnumber_to_tbox(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_to_tbox(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tbool_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_value_at_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("bool *") +def tbool_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -6791,9 +6376,9 @@ def tbool_value_at_timestamptz( return None -def tbool_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("bool *") +def tbool_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('bool *') result = _lib.tbool_value_n(temp_converted, n, out_result) _check_error() if result: @@ -6801,223 +6386,200 @@ def tbool_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> An return None -def tbool_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "bool *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tbool_values(temp_converted, count_converted) +def tbool_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'bool *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_duration( - temp: Annotated[_ffi.CData, "const Temporal *"], boundspan: bool -) -> Annotated[_ffi.CData, "Interval *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_duration(temp: Annotated[_ffi.CData, 'const Temporal *'], boundspan: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_instant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TSequence *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_sequence(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "TimestampTz"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "uint32"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_hash(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_instant_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TInstant **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_instants(temp_converted, count_converted) +def temporal_instants(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TInstant **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_interp(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "const char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_interp(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'const char *']: + 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_lower_inc(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_lower_inc(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + 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_max_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_max_instant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_min_instant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_instants(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_sequences(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_timestamps(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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_segm_duration( - temp: Annotated[_ffi.CData, "const Temporal *"], - duration: Annotated[_ffi.CData, "const Interval *"], - atleast: bool, - strict: bool, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) +def temporal_segm_duration(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], atleast: bool, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) result = _lib.temporal_segm_duration(temp_converted, duration_converted, atleast, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_segments( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_segments(temp_converted, count_converted) +def temporal_segments(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_sequence_n( - temp: Annotated[_ffi.CData, "const Temporal *"], i: int -) -> Annotated[_ffi.CData, "TSequence *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_sequence_n(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_sequences(temp_converted, count_converted) +def temporal_sequences(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_start_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_instant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TSequence *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_sequence(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "TimestampTz"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"], - maxdist: float, - minduration: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - minduration_converted = _ffi.cast("const Interval *", minduration) +def temporal_stops(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdist: float, minduration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "const char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_subtype(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'const char *']: + 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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_time(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_timestamps( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[int, "TimestampTz *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_timestamps(temp_converted, count_converted) +def temporal_timestamps(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_timestamptz_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> int: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("TimestampTz *") +def temporal_timestamptz_n(temp: Annotated[_ffi.CData, '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: @@ -7025,47 +6587,45 @@ def temporal_timestamptz_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: i return None -def temporal_upper_inc(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_upper_inc(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + 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 tfloat_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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_value_at_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("double *") +def tfloat_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -7073,9 +6633,9 @@ def tfloat_value_at_timestamptz( return None -def tfloat_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("double *") +def tfloat_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('double *') result = _lib.tfloat_value_n(temp_converted, n, out_result) _check_error() if result: @@ -7083,50 +6643,46 @@ def tfloat_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> A return None -def tfloat_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "double *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloat_values(temp_converted, count_converted) +def tfloat_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'double *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tint_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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_value_at_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("int *") +def tint_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -7134,9 +6690,9 @@ def tint_value_at_timestamptz( return None -def tint_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("int *") +def tint_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('int *') result = _lib.tint_value_n(temp_converted, n, out_result) _check_error() if result: @@ -7144,82 +6700,78 @@ def tint_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Ann return None -def tint_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "int *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tint_values(temp_converted, count_converted) +def tint_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'int *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tnumber_avg_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_avg_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_avg_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_integral(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_integral(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_twavg(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_valuespans(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 ttext_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: + 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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: + 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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: + 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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: + 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_value_at_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[list, "text **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("text **") +def ttext_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[list, '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: @@ -7227,9 +6779,9 @@ def ttext_value_at_timestamptz( return None -def ttext_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[list, "text **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("text **") +def ttext_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[list, 'text **']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('text **') result = _lib.ttext_value_n(temp_converted, n, out_result) _check_error() if result: @@ -7237,4449 +6789,3860 @@ def ttext_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> An return None -def ttext_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "text **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.ttext_values(temp_converted, count_converted) +def ttext_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'text **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def float_degrees(value: float, normalize: bool) -> Annotated[float, "double"]: +def float_degrees(value: float, normalize: bool) -> Annotated[float, 'double']: result = _lib.float_degrees(value, normalize) _check_error() return result if result != _ffi.NULL else None -def temparr_round(temp: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "Temporal **"]: - temp_converted = [_ffi.cast("Temporal *", x) for x in temp] +def temparr_round(temp: Annotated[list, 'Temporal **'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'Temporal **']: + temp_converted = [_ffi.cast('Temporal *', x) for x in temp] result = _lib.temparr_round(temp_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def temporal_round(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_round(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_round(temp_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def temporal_scale_time( - temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) +def temporal_scale_time(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_set_interp(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_set_interp(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_scale_time( - temp: Annotated[_ffi.CData, "const Temporal *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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 +def temporal_shift_scale_time(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], shift: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - shift_converted = _ffi.cast("const Interval *", shift) +def temporal_shift_time(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tinstant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tsequence(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_to_tsequence(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequenceset( - temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tsequenceset(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_to_tsequenceset(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloat_ceil(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_ceil(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_ceil(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_degrees( - temp: Annotated[_ffi.CData, "const Temporal *"], normalize: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_degrees(temp: Annotated[_ffi.CData, 'const Temporal *'], normalize: bool) -> Annotated[_ffi.CData, '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_floor(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_floor(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_floor(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_radians(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_radians(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tfloat_scale_value( - temp: Annotated[_ffi.CData, "const Temporal *"], width: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], width: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], shift: float, width: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_shift_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: float, width: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], shift: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_shift_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], width: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], width: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], shift: int, width: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_shift_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: int, width: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], shift: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_shift_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Temporal *"], - inst: Annotated[_ffi.CData, "const TInstant *"], - interp: InterpolationType, - maxdist: float, - maxt: Annotated[_ffi.CData, "const Interval *"] | None, - expand: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("Temporal *", temp) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) if maxt is not None else _ffi.NULL +def temporal_append_tinstant(temp: Annotated[_ffi.CData, 'Temporal *'], inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType, maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'] | None, expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('Temporal *', temp) + inst_converted = _ffi.cast('const TInstant *', inst) + maxt_converted = _ffi.cast('const Interval *', maxt) if maxt is not None else _ffi.NULL result = _lib.temporal_append_tinstant(temp_converted, inst_converted, interp, maxdist, maxt_converted, expand) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tsequence( - temp: Annotated[_ffi.CData, "Temporal *"], seq: Annotated[_ffi.CData, "const TSequence *"], expand: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("Temporal *", temp) - seq_converted = _ffi.cast("const TSequence *", seq) +def temporal_append_tsequence(temp: Annotated[_ffi.CData, 'Temporal *'], seq: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, '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_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_delete_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_delete_tstzset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *'], connect: bool) -> Annotated[_ffi.CData, '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_delete_tstzspan( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_delete_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_delete_tstzspanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], connect: bool) -> Annotated[_ffi.CData, '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_insert( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_insert(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_merge(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[list, "Temporal **"], count: int) -> Annotated[_ffi.CData, "Temporal *"]: - temparr_converted = [_ffi.cast("Temporal *", x) for x in temparr] +def temporal_merge_array(temparr: Annotated[list, 'Temporal **'], count: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_update(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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 temporal_after_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_after_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_after_timestamptz(temp_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_at_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_at_max(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_at_min(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_at_tstzset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_tstzspan( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_at_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_at_tstzspanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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_values( - temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_at_values(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_before_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_before_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_before_timestamptz(temp_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_minus_max(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_minus_min(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_minus_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_minus_tstzset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_tstzspan( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_minus_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_minus_tstzspanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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_values( - temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_minus_values(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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 tint_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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 tnumber_at_span( - temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_at_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_at_spanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def tnumber_at_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_minus_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_minus_spanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def tnumber_minus_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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 ttext_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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 temporal_cmp( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_cmp(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_eq(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_ge(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_gt(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_le(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_lt(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_ne(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 always_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_eq_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_eq_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, '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 always_eq_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_eq_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_eq_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_eq_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_eq_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 always_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ge_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ge_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_ge_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_ge_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_ge_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_ge_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.always_ge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_gt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_gt_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_gt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_gt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_gt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_gt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.always_gt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_le_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_le_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_le_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_le_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_le_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_le_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.always_le_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_lt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_lt_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_lt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_lt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_lt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_lt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.always_lt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ne_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ne_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, '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 always_ne_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_ne_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def always_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 always_ne_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 always_ne_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 always_ne_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_eq_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_eq_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, '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 ever_eq_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_eq_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_eq_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_eq_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_eq_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ge_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ge_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_ge_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_ge_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_ge_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_ge_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_gt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_gt_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_gt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_gt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_gt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_gt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_le_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_le_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_le_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_le_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_le_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_le_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_lt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_lt_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_lt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_lt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_lt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_lt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 ever_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ne_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ne_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, '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 ever_ne_temporal_temporal( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_ne_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: +def ever_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + 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 ever_ne_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, '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 ever_ne_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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 ever_ne_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, '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 teq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def teq_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def teq_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tge_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def tge_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tgt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def tgt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tle_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def tle_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tlt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def tlt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tne_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: +def tne_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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 temporal_spans( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_spans(temp_converted, count_converted) +def temporal_spans(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_spans(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_split_each_n_spans( - temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_split_each_n_spans(temp_converted, elem_count, count_converted) +def temporal_split_each_n_spans(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_split_each_n_spans(temp_converted, elem_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_split_n_spans( - temp: Annotated[_ffi.CData, "const Temporal *"], span_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_split_n_spans(temp_converted, span_count, count_converted) +def temporal_split_n_spans(temp: Annotated[_ffi.CData, 'const Temporal *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_split_n_spans(temp_converted, span_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnumber_split_each_n_tboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_split_each_n_tboxes(temp_converted, elem_count, count_converted) +def tnumber_split_each_n_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tnumber_split_each_n_tboxes(temp_converted, elem_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnumber_split_n_tboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], box_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_split_n_tboxes(temp_converted, box_count, count_converted) +def tnumber_split_n_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tnumber_split_n_tboxes(temp_converted, box_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnumber_tboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_tboxes(temp_converted, count_converted) +def tnumber_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tnumber_tboxes(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def adjacent_numspan_tnumber( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def adjacent_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def adjacent_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def adjacent_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contained_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contained_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def contained_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contains_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contains_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def contains_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overlaps_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overlaps_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overlaps_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def same_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def same_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def same_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 after_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def after_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def after_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 before_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def before_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def before_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 left_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def left_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def left_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def left_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 overafter_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overafter_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overafter_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 overbefore_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overbefore_temporal_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overbefore_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tstzspan_temporal( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 overleft_numspan_tnumber( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overleft_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overleft_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overleft_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 overright_numspan_tnumber( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overright_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overright_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overright_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 right_numspan_tnumber( - s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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_tbox_tnumber( - box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def right_tnumber_numspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def right_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def right_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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 tand_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tand_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tand_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tand_tbool_tbool(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_when_true(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnot_tbool(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tor_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tor_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tor_tbool_tbool(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_float_tfloat(d: float, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_int_tint(i: int, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_tfloat_float(tnumber: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_tint_int(tnumber: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def add_tnumber_tnumber(tnumber1: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_float_tfloat(d: float, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_int_tint(i: int, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_tfloat_float(tnumber: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_tint_int(tnumber: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def div_tnumber_tnumber(tnumber1: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 mult_float_tfloat( - d: float, tnumber: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_float_tfloat(d: float, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_int_tint(i: int, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_tfloat_float(tnumber: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_tint_int(tnumber: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def mult_tnumber_tnumber(tnumber1: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_float_tfloat(d: float, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_int_tint(i: int, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_tfloat_float(tnumber: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_tint_int(tnumber: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def sub_tnumber_tnumber(tnumber1: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 temporal_derivative(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_derivative(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_derivative(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_exp(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_exp(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_exp(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_ln(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_ln(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_ln(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_log10(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_log10(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_log10(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_abs(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_abs(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_trend(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_trend(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_trend(temp_converted) _check_error() return result if result != _ffi.NULL else None -def float_angular_difference(degrees1: float, degrees2: float) -> Annotated[float, "double"]: +def float_angular_difference(degrees1: float, degrees2: float) -> Annotated[float, 'double']: result = _lib.float_angular_difference(degrees1, degrees2) _check_error() return result if result != _ffi.NULL else None -def tnumber_angular_difference(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_angular_difference(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_delta_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: +def textcat_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], txt: str -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def textcat_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def textcat_ttext_ttext(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_initcap(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_initcap(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 ttext_upper(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_upper(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_lower(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tdistance_tfloat_float( - temp: Annotated[_ffi.CData, "const Temporal *"], d: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tdistance_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tdistance_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tdistance_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tdistance_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tdistance_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnumber_tnumber( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tdistance_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tdistance_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tboxfloat_tboxfloat( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[float, "double"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def nad_tboxfloat_tboxfloat(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, '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 -def nad_tboxint_tboxint( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[int, "int"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def nad_tboxint_tboxint(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def nad_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tfloat_tfloat(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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_tfloat_tbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def nad_tfloat_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.nad_tfloat_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def nad_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[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_tbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def nad_tint_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + 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_tint_tint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tint_tint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 tbool_tand_transfn( - state: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_extent_transfn(s: Annotated[_ffi.CData, 'Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "Temporal *"]: - state_converted = _ffi.cast("SkipList *", state) +def temporal_tagg_finalfn(state: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tfloat_wmax_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tfloat_wmin_transfn( - state: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tfloat_wmin_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tfloat_wsum_transfn( - state: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tfloat_wsum_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 timestamptz_tcount_transfn( - state: Annotated[_ffi.CData, "SkipList *"] | None, t: int -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, t: int) -> Annotated[_ffi.CData, '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 tint_tmax_transfn( - state: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tint_wmax_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tint_wmin_transfn( - state: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tint_wmin_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tint_wsum_transfn( - state: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tint_wsum_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tnumber_extent_transfn( - box: Annotated[_ffi.CData, "TBox *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'TBox *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_tavg_finalfn(state: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "Temporal *"]: - state_converted = _ffi.cast("SkipList *", state) +def tnumber_tavg_finalfn(state: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - interv: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interv_converted = _ffi.cast("const Interval *", interv) +def tnumber_wavg_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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 tstzset_tcount_transfn( - state: Annotated[_ffi.CData, "SkipList *"] | None, s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 ttext_tmax_transfn( - state: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_dp( - temp: Annotated[_ffi.CData, "const Temporal *"], eps_dist: float, synchronized: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_dp(temp: Annotated[_ffi.CData, 'const Temporal *'], eps_dist: float, synchronized: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], eps_dist: float, synchronized: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_max_dist(temp: Annotated[_ffi.CData, 'const Temporal *'], eps_dist: float, synchronized: bool) -> Annotated[_ffi.CData, '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_simplify_min_dist( - temp: Annotated[_ffi.CData, "const Temporal *"], dist: float -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_min_dist(temp: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], mint: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - mint_converted = _ffi.cast("const Interval *", mint) +def temporal_simplify_min_tdelta(temp: Annotated[_ffi.CData, 'const Temporal *'], mint: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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_tprecision( - temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], origin: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) +def temporal_tprecision(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], - duration: Annotated[_ffi.CData, "const Interval *"], - origin: int, - interp: InterpolationType, -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int, interp: InterpolationType) -> Annotated[_ffi.CData, '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, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_distance( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_dyntimewarp_distance(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Match *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_dyntimewarp_path(temp1_converted, temp2_converted, count_converted) +def temporal_dyntimewarp_path(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Match *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_frechet_distance( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_frechet_distance(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Match *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_frechet_path(temp1_converted, temp2_converted, count_converted) +def temporal_frechet_path(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Match *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def temporal_hausdorff_distance( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_hausdorff_distance(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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 temporal_time_bins( - temp: Annotated[_ffi.CData, "const Temporal *"], - duration: Annotated[_ffi.CData, "const Interval *"], - origin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_time_bins(temp_converted, duration_converted, origin_converted, count_converted) +def temporal_time_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) + count = _ffi.new('int *') + result = _lib.temporal_time_bins(temp_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 temporal_time_split( - temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "TimestampTz *"], Annotated[_ffi.CData, "int"]]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - time_bins = _ffi.new("TimestampTz **") - count = _ffi.new("int *") +def temporal_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + time_bins = _ffi.new('TimestampTz **') + count = _ffi.new('int *') result = _lib.temporal_time_split(temp_converted, duration_converted, torigin_converted, time_bins, count) _check_error() return result if result != _ffi.NULL else None, time_bins[0], count[0] -def tfloat_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloat_time_boxes(temp_converted, duration_converted, torigin_converted, count_converted) +def tfloat_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tfloat_time_boxes(temp_converted, duration_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 tfloat_value_bins( - temp: Annotated[_ffi.CData, "const Temporal *"], vsize: float, vorigin: float, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloat_value_bins(temp_converted, vsize, vorigin, count_converted) +def tfloat_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tfloat_value_bins(temp_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tfloat_value_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], vsize: float, vorigin: float, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloat_value_boxes(temp_converted, vsize, vorigin, count_converted) +def tfloat_value_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tfloat_value_boxes(temp_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tfloat_value_split( - temp: Annotated[_ffi.CData, "const Temporal *"], size: float, origin: float -) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "double *"], Annotated[_ffi.CData, "int"]]: - temp_converted = _ffi.cast("const Temporal *", temp) - bins = _ffi.new("double **") - count = _ffi.new("int *") +def tfloat_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: float, origin: float) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'double *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + bins = _ffi.new('double **') + count = _ffi.new('int *') result = _lib.tfloat_value_split(temp_converted, size, origin, bins, count) _check_error() return result if result != _ffi.NULL else None, bins[0], count[0] -def tfloat_value_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - vsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: float, - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloat_value_time_boxes( - temp_converted, vsize, duration_converted, vorigin, torigin_converted, count_converted - ) +def tfloat_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tfloat_value_time_boxes(temp_converted, vsize, duration_converted, vorigin, torigin_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tfloat_value_time_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - vsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: float, - torigin: int, -) -> tuple[ - Annotated[_ffi.CData, "Temporal **"], - Annotated[list, "double *"], - Annotated[list, "TimestampTz *"], - Annotated[_ffi.CData, "int"], -]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - value_bins = _ffi.new("double **") - time_bins = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tfloat_value_time_split( - temp_converted, vsize, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count - ) +def tfloat_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'double *'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + value_bins = _ffi.new('double **') + time_bins = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tfloat_value_time_split(temp_converted, vsize, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count) _check_error() return result if result != _ffi.NULL else None, value_bins[0], time_bins[0], count[0] -def tfloatbox_time_tiles( - box: Annotated[_ffi.CData, "const TBox *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloatbox_time_tiles(box_converted, duration_converted, torigin_converted, count_converted) +def tfloatbox_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + box_converted = _ffi.cast('const TBox *', box) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tfloatbox_time_tiles(box_converted, duration_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 tfloatbox_value_tiles( - box: Annotated[_ffi.CData, "const TBox *"], vsize: float, vorigin: float, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - count_converted = _ffi.cast("int *", count) - result = _lib.tfloatbox_value_tiles(box_converted, vsize, vorigin, count_converted) +def tfloatbox_value_tiles(box: Annotated[_ffi.CData, 'const TBox *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + box_converted = _ffi.cast('const TBox *', box) + count = _ffi.new('int *') + result = _lib.tfloatbox_value_tiles(box_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tfloatbox_value_time_tiles( - box: Annotated[_ffi.CData, "const TBox *"], - vsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: float, - torigin: int | None, -) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL - count = _ffi.new("int *") - result = _lib.tfloatbox_value_time_tiles( - box_converted, vsize, duration_converted, vorigin, torigin_converted, count - ) +def tfloatbox_value_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int | None) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + box_converted = _ffi.cast('const TBox *', box) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL + count = _ffi.new('int *') + result = _lib.tfloatbox_value_time_tiles(box_converted, vsize, duration_converted, vorigin, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tint_time_boxes(temp_converted, duration_converted, torigin_converted, count_converted) +def tint_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tint_time_boxes(temp_converted, duration_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 tint_value_bins( - temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tint_value_bins(temp_converted, vsize, vorigin, count_converted) +def tint_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tint_value_bins(temp_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tint_value_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tint_value_boxes(temp_converted, vsize, vorigin, count_converted) +def tint_value_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tint_value_boxes(temp_converted, vsize, vorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tint_value_split( - temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int -) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "int *"], Annotated[_ffi.CData, "int"]]: - temp_converted = _ffi.cast("const Temporal *", temp) - bins = _ffi.new("int **") - count = _ffi.new("int *") +def tint_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'int *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + bins = _ffi.new('int **') + count = _ffi.new('int *') result = _lib.tint_value_split(temp_converted, vsize, vorigin, bins, count) _check_error() return result if result != _ffi.NULL else None, bins[0], count[0] -def tint_value_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - vsize: int, - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: int, - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tint_value_time_boxes( - temp_converted, vsize, duration_converted, vorigin, torigin_converted, count_converted - ) +def tint_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: int, torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tint_value_time_boxes(temp_converted, vsize, duration_converted, vorigin, torigin_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tint_value_time_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - size: int, - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: int, - torigin: int, -) -> tuple[ - Annotated[_ffi.CData, "Temporal **"], - Annotated[list, "int *"], - Annotated[list, "TimestampTz *"], - Annotated[_ffi.CData, "int"], -]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - value_bins = _ffi.new("int **") - time_bins = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tint_value_time_split( - temp_converted, size, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count - ) +def tint_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: int, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: int, torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'int *'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + value_bins = _ffi.new('int **') + time_bins = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tint_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count) _check_error() return result if result != _ffi.NULL else None, value_bins[0], time_bins[0], count[0] -def tintbox_time_tiles( - box: Annotated[_ffi.CData, "const TBox *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tintbox_time_tiles(box_converted, duration_converted, torigin_converted, count_converted) +def tintbox_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + box_converted = _ffi.cast('const TBox *', box) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tintbox_time_tiles(box_converted, duration_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 tintbox_value_tiles( - box: Annotated[_ffi.CData, "const TBox *"], xsize: int, xorigin: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - count_converted = _ffi.cast("int *", count) - result = _lib.tintbox_value_tiles(box_converted, xsize, xorigin, count_converted) +def tintbox_value_tiles(box: Annotated[_ffi.CData, 'const TBox *'], xsize: int, xorigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + box_converted = _ffi.cast('const TBox *', box) + count = _ffi.new('int *') + result = _lib.tintbox_value_tiles(box_converted, xsize, xorigin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tintbox_value_time_tiles( - box: Annotated[_ffi.CData, "const TBox *"], - xsize: int, - duration: Annotated[_ffi.CData, "const Interval *"], - xorigin: int | None, - torigin: int | None, -) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) +def tintbox_value_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], xsize: int, duration: Annotated[_ffi.CData, 'const Interval *'], xorigin: int | None, torigin: int | None) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, '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_value_time_tiles( - 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_value_time_tiles(box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tempsubtype_name(subtype: Annotated[_ffi.CData, "tempSubtype"]) -> Annotated[str, "const char *"]: - subtype_converted = _ffi.cast("tempSubtype", subtype) +def tempsubtype_name(subtype: Annotated[_ffi.CData, 'tempSubtype']) -> Annotated[str, 'const char *']: + 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: Annotated[_ffi.CData, "int16 *"]) -> Annotated[bool, "bool"]: - string_converted = string.encode("utf-8") - subtype_converted = _ffi.cast("int16 *", subtype) +def tempsubtype_from_string(string: str, subtype: Annotated[_ffi.CData, 'int16 *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosOper"]) -> Annotated[str, "const char *"]: - oper_converted = _ffi.cast("meosOper", oper) +def meosoper_name(oper: Annotated[_ffi.CData, 'meosOper']) -> Annotated[str, 'const char *']: + 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) -> Annotated[_ffi.CData, "meosOper"]: - name_converted = name.encode("utf-8") +def meosoper_from_string(name: str) -> Annotated[_ffi.CData, '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: InterpolationType) -> Annotated[str, "const char *"]: +def interptype_name(interp: InterpolationType) -> Annotated[str, 'const char *']: result = _lib.interptype_name(interp) _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) -> Annotated[InterpolationType, "interpType"]: - interp_str_converted = interp_str.encode("utf-8") +def interptype_from_string(interp_str: str) -> Annotated[InterpolationType, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[str, "const char *"]: - type_converted = _ffi.cast("meosType", type) +def meostype_name(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[str, 'const char *']: + 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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def temptype_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def settype_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def spantype_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def spantype_spansettype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def spansettype_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def basetype_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: - type_converted = _ffi.cast("meosType", type) +def basetype_settype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_settype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tnumber_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def geo_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def geo_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.geo_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def time_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def time_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def set_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def numset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_numset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def timeset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def set_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_set_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - settype_converted = _ffi.cast("meosType", settype) +def alphanumset_type(settype: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def geoset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_geoset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def spatialset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_spatialset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def span_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def span_canon_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def span_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.span_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def type_span_bbox(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def type_span_bbox(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.type_span_bbox(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_tbox_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def span_tbox_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.span_tbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_span_tbox_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_span_tbox_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_span_tbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def numspan_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def numspan_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_numspan_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def timespan_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def timespan_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def spanset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.spanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def timespanset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def timespanset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_timespanset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def temporal_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.temporal_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_continuous(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def temptype_continuous(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def basetype_byvalue(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def basetype_varlength(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[int, "int16"]: - type_converted = _ffi.cast("meosType", type) +def basetype_length(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int16']: + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_length(type_converted) _check_error() return result if result != _ffi.NULL else None -def talpha_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def talpha_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tnumber_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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 ensure_tnumber_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tnumber_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def spatial_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.spatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tspatial_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tspatial_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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 tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tgeo_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tgeo_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, '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 tgeo_type_all(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tgeo_type_all(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tgeo_type_all(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeo_type_all(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tgeo_type_all(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tgeo_type_all(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tgeometry_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tgeometry_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeometry_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tgeometry_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tgeometry_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeodetic_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def tgeodetic_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.tgeodetic_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeodetic_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tgeodetic_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tgeodetic_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tnumber_tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def geo_as_ewkb( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], endian: str, size: Annotated[_ffi.CData, "size_t *"] -) -> Annotated[_ffi.CData, "uint8_t *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - endian_converted = endian.encode("utf-8") - size_converted = _ffi.cast("size_t *", size) +def geo_as_ewkb(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], endian: str, size: Annotated[_ffi.CData, 'size_t *']) -> Annotated[_ffi.CData, 'uint8_t *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + endian_converted = endian.encode('utf-8') + size_converted = _ffi.cast('size_t *', size) result = _lib.geo_as_ewkb(gs_converted, endian_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def geo_as_ewkt(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], precision: int) -> Annotated[str, "char *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_as_ewkt(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], precision: int) -> Annotated[str, 'char *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_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 geo_as_geojson( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], option: int, precision: int, srs: str | None -) -> Annotated[str, "char *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL +def geo_as_geojson(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], option: int, precision: int, srs: str | None) -> Annotated[str, 'char *']: + 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") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geo_as_hexewkb(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], endian: str) -> Annotated[str, "char *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - endian_converted = endian.encode("utf-8") +def geo_as_hexewkb(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], endian: str) -> Annotated[str, 'char *']: + 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") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geo_as_text(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], precision: int) -> Annotated[str, "char *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_as_text(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], precision: int) -> Annotated[str, 'char *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_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 geo_from_ewkb( - wkb: Annotated[_ffi.CData, "const uint8_t *"], wkb_size: Annotated[_ffi.CData, "size_t"], srid: int -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - wkb_converted = _ffi.cast("const uint8_t *", wkb) - wkb_size_converted = _ffi.cast("size_t", wkb_size) - srid_converted = _ffi.cast("int32", srid) +def geo_from_ewkb(wkb: Annotated[_ffi.CData, 'const uint8_t *'], wkb_size: Annotated[_ffi.CData, 'size_t'], srid: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + wkb_converted = _ffi.cast('const uint8_t *', wkb) + wkb_size_converted = _ffi.cast('size_t', wkb_size) + srid_converted = _ffi.cast('int32', srid) result = _lib.geo_from_ewkb(wkb_converted, wkb_size_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_from_geojson(geojson: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geojson_converted = geojson.encode("utf-8") +def geo_from_geojson(geojson: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geojson_converted = geojson.encode('utf-8') result = _lib.geo_from_geojson(geojson_converted) _check_error() return result if result != _ffi.NULL else None -def geo_from_text(wkt: str, srid: Annotated[_ffi.CData, "int32_t"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - wkt_converted = wkt.encode("utf-8") - srid_converted = _ffi.cast("int32_t", srid) +def geo_from_text(wkt: str, srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + wkt_converted = wkt.encode('utf-8') + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geo_from_text(wkt_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_out(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[str, "char *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_out(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[str, 'char *']: + 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 geog_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - wkt_converted = wkt.encode("utf-8") +def geog_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + wkt_converted = wkt.encode('utf-8') result = _lib.geog_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geog_in(string: str, typmod: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def geog_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.geog_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def geom_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - wkt_converted = wkt.encode("utf-8") +def geom_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + wkt_converted = wkt.encode('utf-8') result = _lib.geom_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geom_in(string: str, typmod: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def geom_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.geom_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def box3d_make( - xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "BOX3D *"]: - srid_converted = _ffi.cast("int32_t", srid) +def box3d_make(xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'BOX3D *']: + srid_converted = _ffi.cast('int32_t', srid) result = _lib.box3d_make(xmin, xmax, ymin, ymax, zmin, zmax, srid_converted) _check_error() return result if result != _ffi.NULL else None -def box3d_out(box: Annotated[_ffi.CData, "const BOX3D *"], maxdd: int) -> Annotated[str, "char *"]: - box_converted = _ffi.cast("const BOX3D *", box) +def box3d_out(box: Annotated[_ffi.CData, 'const BOX3D *'], maxdd: int) -> Annotated[str, 'char *']: + box_converted = _ffi.cast('const BOX3D *', box) result = _lib.box3d_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 gbox_make( - hasz: bool, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float -) -> Annotated[_ffi.CData, "GBOX *"]: +def gbox_make(hasz: bool, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float) -> Annotated[_ffi.CData, 'GBOX *']: result = _lib.gbox_make(hasz, xmin, xmax, ymin, ymax, zmin, zmax) _check_error() return result if result != _ffi.NULL else None -def gbox_out(box: Annotated[_ffi.CData, "const GBOX *"], maxdd: int) -> Annotated[str, "char *"]: - box_converted = _ffi.cast("const GBOX *", box) +def gbox_out(box: Annotated[_ffi.CData, 'const GBOX *'], maxdd: int) -> Annotated[str, 'char *']: + box_converted = _ffi.cast('const GBOX *', box) result = _lib.gbox_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 geo_copy(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geo_copy(g: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geo_copy(g_converted) _check_error() return result if result != _ffi.NULL else None -def geogpoint_make2d( - srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - srid_converted = _ffi.cast("int32_t", srid) +def geogpoint_make2d(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geogpoint_make2d(srid_converted, x, y) _check_error() return result if result != _ffi.NULL else None -def geogpoint_make3dz( - srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float, z: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - srid_converted = _ffi.cast("int32_t", srid) +def geogpoint_make3dz(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float, z: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geogpoint_make3dz(srid_converted, x, y, z) _check_error() return result if result != _ffi.NULL else None -def geompoint_make2d( - srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - srid_converted = _ffi.cast("int32_t", srid) +def geompoint_make2d(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geompoint_make2d(srid_converted, x, y) _check_error() return result if result != _ffi.NULL else None -def geompoint_make3dz( - srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float, z: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - srid_converted = _ffi.cast("int32_t", srid) +def geompoint_make3dz(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float, z: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geompoint_make3dz(srid_converted, x, y, z) _check_error() return result if result != _ffi.NULL else None -def geom_to_geog(geom: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("const GSERIALIZED *", geom) +def geom_to_geog(geom: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geom_converted = _ffi.cast('const GSERIALIZED *', geom) result = _lib.geom_to_geog(geom_converted) _check_error() return result if result != _ffi.NULL else None -def geog_to_geom(geog: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geog_converted = _ffi.cast("const GSERIALIZED *", geog) +def geog_to_geom(geog: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geog_converted = _ffi.cast('const GSERIALIZED *', geog) result = _lib.geog_to_geom(geog_converted) _check_error() return result if result != _ffi.NULL else None -def geo_is_empty(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[bool, "bool"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geo_is_empty(g: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geo_is_empty(g_converted) _check_error() return result if result != _ffi.NULL else None -def geo_is_unitary(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[bool, "bool"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_is_unitary(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_is_unitary(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_typename(type: int) -> Annotated[str, "const char *"]: +def geo_typename(type: int) -> Annotated[str, 'const char *']: result = _lib.geo_typename(type) _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 geog_area(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geog_area(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geog_area(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_centroid( - g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geog_centroid(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geog_centroid(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_length(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geog_length(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geog_length(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_perimeter(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: - g_converted = _ffi.cast("const GSERIALIZED *", g) +def geog_perimeter(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.geog_perimeter(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geom_azimuth( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "double"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) - out_result = _ffi.new("double *") +def geom_azimuth(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'double']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) + out_result = _ffi.new('double *') result = _lib.geom_azimuth(gs1_converted, gs2_converted, out_result) _check_error() if result: @@ -11687,537 +10650,457 @@ def geom_azimuth( return None -def geom_length(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[float, "double"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_length(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_length(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_perimeter(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[float, "double"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_perimeter(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_perimeter(gs_converted) _check_error() return result if result != _ffi.NULL else None -def line_numpoints(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def line_numpoints(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.line_numpoints(gs_converted) _check_error() return result if result != _ffi.NULL else None -def line_point_n(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("const GSERIALIZED *", geom) +def line_point_n(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], n: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geom_converted = _ffi.cast('const GSERIALIZED *', geom) result = _lib.line_point_n(geom_converted, n) _check_error() return result if result != _ffi.NULL else None -def geo_reverse(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_reverse(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_reverse(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_round(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], maxdd: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_round(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], maxdd: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_round(gs_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def geo_set_srid( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - srid_converted = _ffi.cast("int32_t", srid) +def geo_set_srid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.geo_set_srid(gs_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_srid(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "int32_t"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_srid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'int32_t']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_srid(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_transform( - geom: Annotated[_ffi.CData, "const GSERIALIZED *"], srid_to: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("const GSERIALIZED *", geom) - srid_to_converted = _ffi.cast("int32_t", srid_to) +def geo_transform(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], srid_to: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geom_converted = _ffi.cast('const GSERIALIZED *', geom) + srid_to_converted = _ffi.cast('int32_t', srid_to) result = _lib.geo_transform(geom_converted, srid_to_converted) _check_error() return result if result != _ffi.NULL else None -def geo_transform_pipeline( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - pipeline: str, - srid_to: Annotated[_ffi.CData, "int32_t"], - is_forward: bool, -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - pipeline_converted = pipeline.encode("utf-8") - srid_to_converted = _ffi.cast("int32_t", srid_to) +def geo_transform_pipeline(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], pipeline: str, srid_to: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + pipeline_converted = pipeline.encode('utf-8') + srid_to_converted = _ffi.cast('int32_t', srid_to) result = _lib.geo_transform_pipeline(gs_converted, pipeline_converted, srid_to_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def geo_collect_garray(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] +def geo_collect_garray(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] result = _lib.geo_collect_garray(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geo_makeline_garray(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] +def geo_makeline_garray(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] result = _lib.geo_makeline_garray(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geo_num_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_num_points(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_num_points(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_num_geos(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_num_geos(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_num_geos(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_geo_n(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("const GSERIALIZED *", geom) +def geo_geo_n(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], n: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geom_converted = _ffi.cast('const GSERIALIZED *', geom) result = _lib.geo_geo_n(geom_converted, n) _check_error() return result if result != _ffi.NULL else None -def geo_pointarr( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "GSERIALIZED **"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_pointarr(gs_converted, count_converted) +def geo_pointarr(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + count = _ffi.new('int *') + result = _lib.geo_pointarr(gs_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geo_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_points(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_points(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_array_union(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] +def geom_array_union(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] result = _lib.geom_array_union(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geom_boundary(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_boundary(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_boundary(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_buffer( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], size: float, params: str -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - params_converted = params.encode("utf-8") +def geom_buffer(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], size: float, params: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + params_converted = params.encode('utf-8') result = _lib.geom_buffer(gs_converted, size, params_converted) _check_error() return result if result != _ffi.NULL else None -def geom_centroid(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_centroid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_centroid(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_convex_hull(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_convex_hull(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_convex_hull(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_difference2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_difference2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_difference2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersection2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_intersection2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_intersection2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersection2d_coll( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_intersection2d_coll(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_intersection2d_coll(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_min_bounding_radius( - geom: Annotated[_ffi.CData, "const GSERIALIZED *"], radius: Annotated[_ffi.CData, "double *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - geom_converted = _ffi.cast("const GSERIALIZED *", geom) - radius_converted = _ffi.cast("double *", radius) +def geom_min_bounding_radius(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], radius: Annotated[_ffi.CData, 'double *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + geom_converted = _ffi.cast('const GSERIALIZED *', geom) + radius_converted = _ffi.cast('double *', radius) result = _lib.geom_min_bounding_radius(geom_converted, radius_converted) _check_error() return result if result != _ffi.NULL else None -def geom_shortestline2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], s2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - s2_converted = _ffi.cast("const GSERIALIZED *", s2) +def geom_shortestline2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], s2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + s2_converted = _ffi.cast('const GSERIALIZED *', s2) result = _lib.geom_shortestline2d(gs1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_shortestline3d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], s2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - s2_converted = _ffi.cast("const GSERIALIZED *", s2) +def geom_shortestline3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], s2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + s2_converted = _ffi.cast('const GSERIALIZED *', s2) result = _lib.geom_shortestline3d(gs1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_unary_union( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], prec: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_unary_union(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], prec: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_unary_union(gs_converted, prec) _check_error() return result if result != _ffi.NULL else None -def line_interpolate_point( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], distance_fraction: float, repeat: bool -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def line_interpolate_point(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], distance_fraction: float, repeat: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.line_interpolate_point(gs_converted, distance_fraction, repeat) _check_error() return result if result != _ffi.NULL else None -def line_locate_point( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def line_locate_point(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.line_locate_point(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def line_substring( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], from_: float, to: float -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def line_substring(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], from_: float, to: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.line_substring(gs_converted, from_, to) _check_error() return result if result != _ffi.NULL else None -def geog_dwithin( - g1: Annotated[_ffi.CData, "const GSERIALIZED *"], - g2: Annotated[_ffi.CData, "const GSERIALIZED *"], - tolerance: float, - use_spheroid: bool, -) -> Annotated[bool, "bool"]: - g1_converted = _ffi.cast("const GSERIALIZED *", g1) - g2_converted = _ffi.cast("const GSERIALIZED *", g2) +def geog_dwithin(g1: Annotated[_ffi.CData, 'const GSERIALIZED *'], g2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float, use_spheroid: bool) -> Annotated[bool, 'bool']: + g1_converted = _ffi.cast('const GSERIALIZED *', g1) + g2_converted = _ffi.cast('const GSERIALIZED *', g2) result = _lib.geog_dwithin(g1_converted, g2_converted, tolerance, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_intersects( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], - gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], - use_spheroid: bool, -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geog_intersects(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geog_intersects(gs1_converted, gs2_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geom_contains( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_contains(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_contains(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_covers( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_covers(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_covers(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_disjoint2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_disjoint2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_disjoint2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_dwithin2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], - gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], - tolerance: float, -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_dwithin2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_dwithin2d(gs1_converted, gs2_converted, tolerance) _check_error() return result if result != _ffi.NULL else None -def geom_dwithin3d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], - gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], - tolerance: float, -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_dwithin3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_dwithin3d(gs1_converted, gs2_converted, tolerance) _check_error() return result if result != _ffi.NULL else None -def geom_intersects2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_intersects2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_intersects2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersects3d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_intersects3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_intersects3d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_relate_pattern( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], patt: str -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) - patt_converted = patt.encode("utf-8") +def geom_relate_pattern(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], patt: str) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) + patt_converted = patt.encode('utf-8') result = _lib.geom_relate_pattern(gs1_converted, gs2_converted, patt_converted) _check_error() return result if result != _ffi.NULL else None -def geom_touches( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_touches(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_touches(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_stboxes( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_stboxes(gs_converted, count_converted) +def geo_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + count = _ffi.new('int *') + result = _lib.geo_stboxes(gs_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geo_split_each_n_stboxes( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], elem_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_split_each_n_stboxes(gs_converted, elem_count, count_converted) +def geo_split_each_n_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + count = _ffi.new('int *') + result = _lib.geo_split_each_n_stboxes(gs_converted, elem_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geo_split_n_stboxes( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], box_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_split_n_stboxes(gs_converted, box_count, count_converted) +def geo_split_n_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + count = _ffi.new('int *') + result = _lib.geo_split_n_stboxes(gs_converted, box_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geog_distance( - g1: Annotated[_ffi.CData, "const GSERIALIZED *"], g2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - g1_converted = _ffi.cast("const GSERIALIZED *", g1) - g2_converted = _ffi.cast("const GSERIALIZED *", g2) +def geog_distance(g1: Annotated[_ffi.CData, 'const GSERIALIZED *'], g2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + g1_converted = _ffi.cast('const GSERIALIZED *', g1) + g2_converted = _ffi.cast('const GSERIALIZED *', g2) result = _lib.geog_distance(g1_converted, g2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_distance2d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_distance2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_distance2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_distance3d( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geom_distance3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geom_distance3d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_equals( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geo_equals(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.geo_equals(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_same( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def geo_same(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def geogset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def geogset_in(string: str) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def geomset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: + string_converted = string.encode('utf-8') result = _lib.geomset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_as_text(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def spatialset_as_text(set: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: + set_converted = _ffi.cast('const Set *', set) result = _lib.spatialset_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 spatialset_as_ewkt(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: - set_converted = _ffi.cast("const Set *", set) +def spatialset_as_ewkt(set: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: + set_converted = _ffi.cast('const Set *', set) result = _lib.spatialset_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_make(values: Annotated[list, "GSERIALIZED **"]) -> Annotated[_ffi.CData, "Set *"]: - values_converted = [_ffi.cast("GSERIALIZED *", x) for x in values] +def geoset_make(values: Annotated[list, 'GSERIALIZED **']) -> Annotated[_ffi.CData, 'Set *']: + values_converted = [_ffi.cast('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 geo_to_set(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Set *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_to_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_to_set(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - s_converted = _ffi.cast("const Set *", s) +def geoset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - s_converted = _ffi.cast("const Set *", s) +def geoset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "GSERIALIZED **"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("GSERIALIZED **") +def geoset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, '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: @@ -12225,370 +11108,326 @@ def geoset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated return None -def geoset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "GSERIALIZED **"]: - s_converted = _ffi.cast("const Set *", s) +def geoset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 contained_geo_set( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def contained_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: + gs_converted = _ffi.cast('const 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 contains_set_geo( - s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def contains_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[bool, '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 geo_union_transfn( - state: Annotated[_ffi.CData, "Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_union_transfn(state: Annotated[_ffi.CData, 'Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: + state_converted = _ffi.cast('Set *', state) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_union_transfn(state_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_geo_set( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def intersection_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 intersection_set_geo( - s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def intersection_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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 minus_geo_set( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def minus_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_set_geo( - s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def minus_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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 union_geo_set( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def union_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 union_set_geo( - s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def union_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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 spatialset_set_srid( - s: Annotated[_ffi.CData, "const Set *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - srid_converted = _ffi.cast("int32_t", srid) +def spatialset_set_srid(s: Annotated[_ffi.CData, 'const Set *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.spatialset_set_srid(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_srid(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "int32_t"]: - s_converted = _ffi.cast("const Set *", s) +def spatialset_srid(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'int32_t']: + s_converted = _ffi.cast('const Set *', s) result = _lib.spatialset_srid(s_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_transform( - s: Annotated[_ffi.CData, "const Set *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - srid_converted = _ffi.cast("int32_t", srid) +def spatialset_transform(s: Annotated[_ffi.CData, 'const Set *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.spatialset_transform(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_transform_pipeline( - s: Annotated[_ffi.CData, "const Set *"], pipelinestr: str, srid: Annotated[_ffi.CData, "int32_t"], is_forward: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - pipelinestr_converted = pipelinestr.encode("utf-8") - srid_converted = _ffi.cast("int32_t", srid) +def spatialset_transform_pipeline(s: Annotated[_ffi.CData, 'const Set *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + pipelinestr_converted = pipelinestr.encode('utf-8') + srid_converted = _ffi.cast('int32_t', srid) result = _lib.spatialset_transform_pipeline(s_converted, pipelinestr_converted, srid_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def stbox_as_hexwkb( - box: Annotated[_ffi.CData, "const STBox *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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_as_wkb( - box: Annotated[_ffi.CData, "const STBox *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: - 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: Annotated[_ffi.CData, 'const STBox *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: + 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 return result_converted -def stbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "STBox *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def stbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, '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 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_in(string: str) -> Annotated[_ffi.CData, "STBox *"]: - string_converted = string.encode("utf-8") +def stbox_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"], maxdd: int) -> Annotated[str, "char *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_out(box: Annotated[_ffi.CData, 'const STBox *'], maxdd: int) -> Annotated[str, 'char *']: + 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 geo_timestamptz_to_stbox( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int -) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - t_converted = _ffi.cast("TimestampTz", t) +def geo_timestamptz_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, '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 geo_tstzspan_to_stbox( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Span *", s) +def geo_tstzspan_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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_copy(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_copy(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"] | None, -) -> Annotated[_ffi.CData, "STBox *"]: - srid_converted = _ffi.cast("int32", srid) - s_converted = _ffi.cast("const Span *", s) if s is not None else _ffi.NULL +def stbox_make(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: Annotated[_ffi.CData, 'const Span *'] | None) -> Annotated[_ffi.CData, 'STBox *']: + srid_converted = _ffi.cast('int32', srid) + s_converted = _ffi.cast('const Span *', s) if s is not None else _ffi.NULL 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 geo_to_stbox(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "STBox *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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 spatialset_to_stbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "STBox *"]: - s_converted = _ffi.cast("const Set *", s) +def spatialset_to_stbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_box3d(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "BOX3D *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_box3d(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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_gbox(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "GBOX *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_gbox(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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_geo(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_geo(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "Span *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_tstzspan(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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 timestamptz_to_stbox(t: int) -> Annotated[_ffi.CData, "STBox *"]: - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_stbox(t: int) -> Annotated[_ffi.CData, '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 tstzset_to_stbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "STBox *"]: - s_converted = _ffi.cast("const Set *", s) +def tstzset_to_stbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "STBox *"]: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_to_stbox(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "STBox *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_to_stbox(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 stbox_area(box: Annotated[_ffi.CData, "const STBox *"], spheroid: bool) -> Annotated[float, "double"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_area(box: Annotated[_ffi.CData, 'const STBox *'], spheroid: bool) -> Annotated[float, 'double']: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_area(box_converted, spheroid) _check_error() return result if result != _ffi.NULL else None -def stbox_hash(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[int, "uint32"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_hash(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[int, 'uint32']: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_hash(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hash_extended(box: Annotated[_ffi.CData, "const STBox *"], seed: int) -> Annotated[int, "uint64"]: - box_converted = _ffi.cast("const STBox *", box) - seed_converted = _ffi.cast("uint64", seed) +def stbox_hash_extended(box: Annotated[_ffi.CData, 'const STBox *'], seed: int) -> Annotated[int, 'uint64']: + box_converted = _ffi.cast('const STBox *', box) + seed_converted = _ffi.cast('uint64', seed) result = _lib.stbox_hash_extended(box_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hast(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_hast(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_hasx(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_hasz(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_isgeodetic(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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_perimeter(box: Annotated[_ffi.CData, "const STBox *"], spheroid: bool) -> Annotated[float, "double"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_perimeter(box: Annotated[_ffi.CData, 'const STBox *'], spheroid: bool) -> Annotated[float, 'double']: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_perimeter(box_converted, spheroid) _check_error() return result if result != _ffi.NULL else None -def stbox_tmax(box: Annotated[_ffi.CData, "const STBox *"]) -> int: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("TimestampTz *") +def stbox_tmax(box: Annotated[_ffi.CData, '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: @@ -12596,9 +11435,9 @@ def stbox_tmax(box: Annotated[_ffi.CData, "const STBox *"]) -> int: return None -def stbox_tmax_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("bool *") +def stbox_tmax_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12606,9 +11445,9 @@ def stbox_tmax_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ff return None -def stbox_tmin(box: Annotated[_ffi.CData, "const STBox *"]) -> int: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("TimestampTz *") +def stbox_tmin(box: Annotated[_ffi.CData, '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: @@ -12616,9 +11455,9 @@ def stbox_tmin(box: Annotated[_ffi.CData, "const STBox *"]) -> int: return None -def stbox_tmin_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("bool *") +def stbox_tmin_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12626,16 +11465,16 @@ def stbox_tmin_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ff return None -def stbox_volume(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[float, "double"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_volume(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_volume(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_xmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_xmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12643,9 +11482,9 @@ def stbox_xmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_xmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_xmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12653,9 +11492,9 @@ def stbox_xmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_ymax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_ymax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12663,9 +11502,9 @@ def stbox_ymax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_ymin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_ymin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12673,9 +11512,9 @@ def stbox_ymin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_zmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_zmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12683,9 +11522,9 @@ def stbox_zmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_zmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "double"]: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_zmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -12693,731 +11532,582 @@ def stbox_zmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CD return None -def stbox_expand_space(box: Annotated[_ffi.CData, "const STBox *"], d: float) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_expand_space(box: Annotated[_ffi.CData, 'const STBox *'], d: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"], interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) - interv_converted = _ffi.cast("const Interval *", interv) +def stbox_expand_time(box: Annotated[_ffi.CData, 'const STBox *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_get_space(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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_quad_split( - box: Annotated[_ffi.CData, "const STBox *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) - count_converted = _ffi.cast("int *", count) - result = _lib.stbox_quad_split(box_converted, count_converted) +def stbox_quad_split(box: Annotated[_ffi.CData, 'const STBox *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def stbox_round(box: Annotated[_ffi.CData, "const STBox *"], maxdd: int) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_round(box: Annotated[_ffi.CData, 'const STBox *'], maxdd: int) -> Annotated[_ffi.CData, '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_shift_scale_time( - box: Annotated[_ffi.CData, "const STBox *"], - shift: Annotated[_ffi.CData, "const Interval *"] | None, - duration: Annotated[_ffi.CData, "const Interval *"] | None, -) -> Annotated[_ffi.CData, "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 +def stbox_shift_scale_time(box: Annotated[_ffi.CData, 'const STBox *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 stboxarr_round( - boxarr: Annotated[_ffi.CData, "const STBox *"], count: int, maxdd: int -) -> Annotated[_ffi.CData, "STBox *"]: - boxarr_converted = _ffi.cast("const STBox *", boxarr) +def stboxarr_round(boxarr: Annotated[_ffi.CData, 'const STBox *'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'STBox *']: + boxarr_converted = _ffi.cast('const STBox *', boxarr) result = _lib.stboxarr_round(boxarr_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def stbox_set_srid( - box: Annotated[_ffi.CData, "const STBox *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) - srid_converted = _ffi.cast("int32_t", srid) +def stbox_set_srid(box: Annotated[_ffi.CData, 'const STBox *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: + box_converted = _ffi.cast('const STBox *', box) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.stbox_set_srid(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_srid(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "int32_t"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_srid(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'int32_t']: + 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_transform( - box: Annotated[_ffi.CData, "const STBox *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) - srid_converted = _ffi.cast("int32_t", srid) +def stbox_transform(box: Annotated[_ffi.CData, 'const STBox *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: + box_converted = _ffi.cast('const STBox *', box) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.stbox_transform(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_transform_pipeline( - box: Annotated[_ffi.CData, "const STBox *"], - pipelinestr: str, - srid: Annotated[_ffi.CData, "int32_t"], - is_forward: bool, -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const STBox *", box) - pipelinestr_converted = pipelinestr.encode("utf-8") - srid_converted = _ffi.cast("int32_t", srid) +def stbox_transform_pipeline(box: Annotated[_ffi.CData, 'const STBox *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'STBox *']: + box_converted = _ffi.cast('const STBox *', box) + pipelinestr_converted = pipelinestr.encode('utf-8') + srid_converted = _ffi.cast('int32_t', 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 adjacent_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def adjacent_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def contained_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 contains_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def contains_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overlaps_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overlaps_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def same_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 above_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def above_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 after_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def after_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 back_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def back_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 before_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def before_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 below_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def below_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 front_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def front_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 left_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def left_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overabove_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overabove_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overafter_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overafter_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overback_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overback_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overbefore_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overbefore_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overbelow_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overbelow_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overfront_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overfront_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overleft_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overleft_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 overright_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overright_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 right_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def right_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 union_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"], strict: bool -) -> Annotated[_ffi.CData, "STBox *"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def union_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *'], strict: bool) -> Annotated[_ffi.CData, '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 intersection_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[_ffi.CData, "STBox *"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def intersection_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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 stbox_cmp( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[int, "int"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_cmp(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[int, '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_eq( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_eq(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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_ge( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_ge(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_gt(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 stbox_le( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_le(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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_lt( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_lt(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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_ne( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_ne(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, '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 tgeogpoint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeogpoint_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeogpoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeogpoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeogpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_from_mfjson(mfjson: str) -> Annotated[_ffi.CData, "Temporal *"]: - mfjson_converted = mfjson.encode("utf-8") +def tgeography_from_mfjson(mfjson: str) -> Annotated[_ffi.CData, 'Temporal *']: + mfjson_converted = mfjson.encode('utf-8') result = _lib.tgeography_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeography_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeography_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeometry_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeometry_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeometry_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeometry_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeompoint_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeompoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tgeompoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tgeompoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_as_ewkt(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_as_ewkt(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_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 tspatial_as_text(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_as_text(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_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 tspatial_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_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 tgeo_from_base_temp( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_from_base_temp(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_from_base_temp(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_make(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int) -> Annotated[_ffi.CData, "TInstant *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - t_converted = _ffi.cast("TimestampTz", t) +def tgeoinst_make(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tgeoinst_make(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_from_base_tstzset( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def tgeoseq_from_base_tstzset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Set *', s) result = _lib.tgeoseq_from_base_tstzset(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_from_base_tstzspan( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - s: Annotated[_ffi.CData, "const Span *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequence *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Span *", s) +def tgeoseq_from_base_tstzspan(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Span *', s) result = _lib.tgeoseq_from_base_tstzspan(gs_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_from_base_tstzspanset( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - ss: Annotated[_ffi.CData, "const SpanSet *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tgeoseqset_from_base_tstzspanset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tgeoseqset_from_base_tstzspanset(gs_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tpoint_from_base_temp( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_from_base_temp(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int) -> Annotated[_ffi.CData, "TInstant *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - t_converted = _ffi.cast("TimestampTz", t) +def tpointinst_make(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, '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_tstzset( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequence *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def tpointseq_from_base_tstzset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 tpointseq_from_base_tstzspan( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - s: Annotated[_ffi.CData, "const Span *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequence *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Span *", s) +def tpointseq_from_base_tstzspan(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Span *', s) result = _lib.tpointseq_from_base_tstzspan(gs_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_coords( - xcoords: Annotated[_ffi.CData, "const double *"], - ycoords: Annotated[_ffi.CData, "const double *"], - zcoords: Annotated[_ffi.CData, "const double *"], - times: int, - count: int, - srid: int, - geodetic: bool, - lower_inc: bool, - upper_inc: bool, - interp: InterpolationType, - normalize: bool, -) -> Annotated[_ffi.CData, "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) - result = _lib.tpointseq_make_coords( - xcoords_converted, - ycoords_converted, - zcoords_converted, - times_converted, - count, - srid_converted, - geodetic, - lower_inc, - upper_inc, - interp, - normalize, - ) +def tpointseq_make_coords(xcoords: Annotated[_ffi.CData, 'const double *'], ycoords: Annotated[_ffi.CData, 'const double *'], zcoords: Annotated[_ffi.CData, 'const double *'], times: int, count: int, srid: int, geodetic: bool, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, '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) + result = _lib.tpointseq_make_coords(xcoords_converted, ycoords_converted, zcoords_converted, times_converted, count, srid_converted, geodetic, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_from_base_tstzspanset( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - ss: Annotated[_ffi.CData, "const SpanSet *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tpointseqset_from_base_tstzspanset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tpointseqset_from_base_tstzspanset(gs_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def box3d_to_stbox(box: Annotated[_ffi.CData, "const BOX3D *"]) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const BOX3D *", box) +def box3d_to_stbox(box: Annotated[_ffi.CData, 'const BOX3D *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const GBOX *"]) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const GBOX *", box) +def gbox_to_stbox(box: Annotated[_ffi.CData, 'const GBOX *']) -> Annotated[_ffi.CData, '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 geomeas_to_tpoint(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geomeas_to_tpoint(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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_tgeography(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeogpoint_to_tgeography(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeogpoint_to_tgeography(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_to_tgeogpoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeography_to_tgeogpoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeography_to_tgeogpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_to_tgeometry(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeography_to_tgeometry(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeography_to_tgeometry(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_to_tgeography(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeometry_to_tgeography(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeometry_to_tgeography(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_to_tgeompoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeometry_to_tgeompoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeometry_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tgeometry(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeompoint_to_tgeometry(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeompoint_to_tgeometry(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_as_mvtgeom( - temp: Annotated[_ffi.CData, "const Temporal *"], - bounds: Annotated[_ffi.CData, "const STBox *"], - extent: Annotated[_ffi.CData, "int32_t"], - buffer: Annotated[_ffi.CData, "int32_t"], - clip_geom: bool, - gsarr: Annotated[list, "GSERIALIZED **"], - timesarr: Annotated[list, "int64 **"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[bool, "bool"]: - 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_converted = _ffi.cast("int *", count) - result = _lib.tpoint_as_mvtgeom( - temp_converted, - bounds_converted, - extent_converted, - buffer_converted, - clip_geom, - gsarr_converted, - timesarr_converted, - count_converted, - ) +def tpoint_as_mvtgeom(temp: Annotated[_ffi.CData, 'const Temporal *'], bounds: Annotated[_ffi.CData, 'const STBox *'], extent: Annotated[_ffi.CData, 'int32_t'], buffer: Annotated[_ffi.CData, 'int32_t'], clip_geom: bool, gsarr: Annotated[list, 'GSERIALIZED **'], timesarr: Annotated[list, 'int64 **']) -> tuple[Annotated[bool, 'bool'], Annotated[_ffi.CData, '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_as_mvtgeom(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 tpoint_tfloat_to_geomeas( - tpoint: Annotated[_ffi.CData, "const Temporal *"], - measure: Annotated[_ffi.CData, "const Temporal *"], - segmentize: bool, -) -> Annotated[list, "GSERIALIZED **"]: - tpoint_converted = _ffi.cast("const Temporal *", tpoint) - measure_converted = _ffi.cast("const Temporal *", measure) - out_result = _ffi.new("GSERIALIZED **") +def tpoint_tfloat_to_geomeas(tpoint: Annotated[_ffi.CData, 'const Temporal *'], measure: Annotated[_ffi.CData, 'const Temporal *'], segmentize: bool) -> Annotated[list, '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: @@ -13425,19 +12115,17 @@ def tpoint_tfloat_to_geomeas( return None -def tspatial_to_stbox(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_to_stbox(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'STBox *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_to_stbox(temp_converted) _check_error() return result if result != _ffi.NULL else None -def bearing_point_point( - gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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: @@ -13445,69 +12133,61 @@ def bearing_point_point( return None -def bearing_tpoint_point( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], invert: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def bearing_tpoint_point(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], invert: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def bearing_tpoint_tpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tgeo_centroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_centroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_centroid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_convex_hull(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_convex_hull(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_convex_hull(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_traversed_area( - temp: Annotated[_ffi.CData, "const Temporal *"], unary_union: bool -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_traversed_area(temp: Annotated[_ffi.CData, 'const Temporal *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_traversed_area(temp_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tgeo_value_at_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[list, "GSERIALIZED **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("GSERIALIZED **") +def tgeo_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[list, 'GSERIALIZED **']: + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('GSERIALIZED **') result = _lib.tgeo_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: @@ -13515,9 +12195,9 @@ def tgeo_value_at_timestamptz( return None -def tgeo_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[list, "GSERIALIZED **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("GSERIALIZED **") +def tgeo_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[list, 'GSERIALIZED **']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('GSERIALIZED **') result = _lib.tgeo_value_n(temp_converted, n, out_result) _check_error() if result: @@ -13525,40 +12205,38 @@ def tgeo_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Ann return None -def tgeo_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "GSERIALIZED **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_values(temp_converted, count_converted) +def tgeo_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tgeo_values(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tpoint_angular_difference(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_angular_difference(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_azimuth(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_cumulative_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_cumulative_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("double *") +def tpoint_direction(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: @@ -13566,2318 +12244,1747 @@ def tpoint_direction(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotat return None -def tpoint_get_x(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_x(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_y(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_z(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_is_simple(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_speed(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_trajectory( - temp: Annotated[_ffi.CData, "const Temporal *"], unary_union: bool -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_trajectory(temp: Annotated[_ffi.CData, 'const Temporal *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_trajectory(temp_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tpoint_twcentroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_twcentroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 tgeo_affine( - temp: Annotated[_ffi.CData, "const Temporal *"], a: Annotated[_ffi.CData, "const AFFINE *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - a_converted = _ffi.cast("const AFFINE *", a) +def tgeo_affine(temp: Annotated[_ffi.CData, 'const Temporal *'], a: Annotated[_ffi.CData, 'const AFFINE *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + a_converted = _ffi.cast('const AFFINE *', a) result = _lib.tgeo_affine(temp_converted, a_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_scale( - temp: Annotated[_ffi.CData, "const Temporal *"], - scale: Annotated[_ffi.CData, "const GSERIALIZED *"], - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - scale_converted = _ffi.cast("const GSERIALIZED *", scale) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) +def tgeo_scale(temp: Annotated[_ffi.CData, 'const Temporal *'], scale: Annotated[_ffi.CData, 'const GSERIALIZED *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + scale_converted = _ffi.cast('const GSERIALIZED *', scale) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) result = _lib.tgeo_scale(temp_converted, scale_converted, sorigin_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_make_simple( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Temporal **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tpoint_make_simple(temp_converted, count_converted) +def tpoint_make_simple(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, '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 tspatial_srid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "int32_t"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_srid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'int32_t']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_srid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_set_srid( - temp: Annotated[_ffi.CData, "const Temporal *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - srid_converted = _ffi.cast("int32_t", srid) +def tspatial_set_srid(temp: Annotated[_ffi.CData, 'const Temporal *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.tspatial_set_srid(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_transform( - temp: Annotated[_ffi.CData, "const Temporal *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - srid_converted = _ffi.cast("int32_t", srid) +def tspatial_transform(temp: Annotated[_ffi.CData, 'const Temporal *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.tspatial_transform(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_transform_pipeline( - temp: Annotated[_ffi.CData, "const Temporal *"], - pipelinestr: str, - srid: Annotated[_ffi.CData, "int32_t"], - is_forward: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - pipelinestr_converted = pipelinestr.encode("utf-8") - srid_converted = _ffi.cast("int32_t", srid) +def tspatial_transform_pipeline(temp: Annotated[_ffi.CData, 'const Temporal *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + pipelinestr_converted = pipelinestr.encode('utf-8') + srid_converted = _ffi.cast('int32_t', srid) result = _lib.tspatial_transform_pipeline(temp_converted, pipelinestr_converted, srid_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tgeo_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tgeo_at_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tgeo_at_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeo_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_value( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tgeo_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.tgeo_at_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tgeo_minus_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tgeo_minus_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tgeo_minus_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeo_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_value( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tgeo_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.tgeo_minus_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tpoint_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tpoint_at_geom(temp_converted, gs_converted, zspan_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_value( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tpoint_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, '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( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tpoint_minus_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tpoint_minus_geom(temp_converted, gs_converted, zspan_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_value( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tpoint_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, '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 always_eq_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.always_eq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def always_eq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.always_eq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_eq_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.always_eq_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.always_ne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def always_ne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.always_ne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_ne_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.always_ne_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ever_eq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def ever_eq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.ever_eq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_eq_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ever_eq_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ever_ne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def ever_ne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.ever_ne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_ne_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ever_ne_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def teq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.teq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tne_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_stboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_stboxes(temp_converted, count_converted) +def tgeo_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tgeo_stboxes(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tgeo_space_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - xsize: float, - ysize: float, - zsize: float, - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - bitmatrix: bool, - border_inc: bool, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_space_boxes( - temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, count_converted - ) +def tgeo_space_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + count = _ffi.new('int *') + result = _lib.tgeo_space_boxes(temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tgeo_space_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - xsize: float, - ysize: float, - zsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - torigin: int, - bitmatrix: bool, - border_inc: bool, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_space_time_boxes( - temp_converted, - xsize, - ysize, - zsize, - duration_converted, - sorigin_converted, - torigin_converted, - bitmatrix, - border_inc, - count_converted, - ) +def tgeo_space_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tgeo_space_time_boxes(temp_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, bitmatrix, border_inc, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tgeo_split_each_n_stboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_split_each_n_stboxes(temp_converted, elem_count, count_converted) +def tgeo_split_each_n_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tgeo_split_each_n_stboxes(temp_converted, elem_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tgeo_split_n_stboxes( - temp: Annotated[_ffi.CData, "const Temporal *"], box_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeo_split_n_stboxes(temp_converted, box_count, count_converted) +def tgeo_split_n_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tgeo_split_n_stboxes(temp_converted, box_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def adjacent_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.adjacent_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def adjacent_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.adjacent_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adjacent_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contained_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def contained_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.contained_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contained_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contains_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def contains_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.contains_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contains_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overlaps_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overlaps_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overlaps_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overlaps_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.same_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def same_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.same_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def same_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.same_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def above_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.above_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def above_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.above_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def above_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def above_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.above_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.after_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def after_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.after_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def after_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.after_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def back_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.back_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def back_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.back_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def back_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def back_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.back_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.before_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def before_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.before_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def before_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.before_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def below_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def below_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.below_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def below_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def below_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.below_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def below_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def below_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.below_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def front_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def front_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.front_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def front_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def front_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.front_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def front_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def front_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.front_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def left_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.left_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def left_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.left_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def left_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def left_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.left_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overabove_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overabove_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overabove_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overabove_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overabove_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overabove_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overafter_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overafter_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overafter_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overafter_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overback_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overback_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overback_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overback_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overback_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overback_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbefore_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overbefore_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overbefore_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbefore_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbelow_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbelow_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overbelow_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overbelow_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbelow_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbelow_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overfront_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overfront_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overfront_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overfront_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overfront_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overfront_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overleft_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overleft_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overleft_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overleft_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overleft_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overright_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overright_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overright_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overright_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overright_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_tspatial( - box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.right_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tspatial_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def right_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.right_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_tspatial_tspatial( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[bool, "bool"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def right_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.right_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def acontains_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.acontains_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def acontains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.acontains_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def acontains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.acontains_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adisjoint_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def adisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.adisjoint_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def adisjoint_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adisjoint_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adwithin_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], dist: float -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def adwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.adwithin_tgeo_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def adwithin_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], dist: float -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def aintersects_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def aintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.aintersects_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def aintersects_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def aintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.aintersects_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def atouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.atouches_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def atouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.atouches_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tpoint_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def atouches_tpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, '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 econtains_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def econtains_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.econtains_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def econtains_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def econtains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.econtains_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def econtains_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def econtains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.econtains_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def ecovers_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ecovers_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def ecovers_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.ecovers_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ecovers_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ecovers_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def edisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.edisjoint_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def edisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.edisjoint_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edwithin_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], dist: float -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def edwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.edwithin_tgeo_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def edwithin_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], dist: float -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def edwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.edwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def eintersects_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def eintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.eintersects_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def eintersects_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def eintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.eintersects_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def etouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.etouches_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def etouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.etouches_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tpoint_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def etouches_tpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, '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_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tcontains_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tcontains_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcontains_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tcontains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tcontains_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcontains_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tcontains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tcontains_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tcovers_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tcovers_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tcovers_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tcovers_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tcovers_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tcovers_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tdisjoint_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tdisjoint_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tdisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tdisjoint_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tdisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tdisjoint_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - dist: float, - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tdwithin_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tdwithin_geo_tgeo(gs_converted, temp_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - dist: float, - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tdwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tdwithin_tgeo_geo(temp_converted, gs_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - dist: float, - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tdwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tdwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tintersects_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tintersects_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tintersects_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tintersects_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_geo_tgeo( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - temp: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def ttouches_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttouches_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def ttouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.ttouches_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], - temp2: Annotated[_ffi.CData, "const Temporal *"], - restr: bool, - atvalue: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ttouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ttouches_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdistance_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tdistance_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tdistance_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tdistance_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tdistance_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_geo( - box: Annotated[_ffi.CData, "const STBox *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - box_converted = _ffi.cast("const STBox *", box) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nad_stbox_geo(box: Annotated[_ffi.CData, 'const STBox *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[float, "double"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def nad_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, '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_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nad_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nad_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tgeo_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def nad_tgeo_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.nad_tgeo_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nad_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nai_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nai_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nai_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nai_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tgeo_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def shortestline_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.shortestline_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tgeo_tgeo( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def shortestline_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.shortestline_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_finalfn(state: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "Temporal *"]: - state_converted = _ffi.cast("SkipList *", state) +def tpoint_tcentroid_finalfn(state: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"], temp: Annotated[_ffi.CData, "Temporal *"] -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("Temporal *", temp) +def tpoint_tcentroid_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'Temporal *']) -> Annotated[_ffi.CData, '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 tspatial_extent_transfn( - box: Annotated[_ffi.CData, "STBox *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("STBox *", box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tspatial_extent_transfn(box: Annotated[_ffi.CData, 'STBox *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'STBox *']: + box_converted = _ffi.cast('STBox *', box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tspatial_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space_tile( - point: Annotated[_ffi.CData, "const GSERIALIZED *"], - xsize: float, - ysize: float, - zsize: float, - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], -) -> Annotated[_ffi.CData, "STBox *"]: - point_converted = _ffi.cast("const GSERIALIZED *", point) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) +def stbox_get_space_tile(point: Annotated[_ffi.CData, 'const GSERIALIZED *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'STBox *']: + point_converted = _ffi.cast('const GSERIALIZED *', point) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) result = _lib.stbox_get_space_tile(point_converted, xsize, ysize, zsize, sorigin_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space_time_tile( - point: Annotated[_ffi.CData, "const GSERIALIZED *"], - t: int, - xsize: float, - ysize: float, - zsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - torigin: int, -) -> Annotated[_ffi.CData, "STBox *"]: - point_converted = _ffi.cast("const GSERIALIZED *", point) - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("const Interval *", duration) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - result = _lib.stbox_get_space_time_tile( - point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted - ) +def stbox_get_space_time_tile(point: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int, xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int) -> Annotated[_ffi.CData, 'STBox *']: + point_converted = _ffi.cast('const GSERIALIZED *', point) + t_converted = _ffi.cast('TimestampTz', t) + duration_converted = _ffi.cast('const Interval *', duration) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + result = _lib.stbox_get_space_time_tile(point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_time_tile( - t: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int -) -> Annotated[_ffi.CData, "STBox *"]: - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) +def stbox_get_time_tile(t: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, 'STBox *']: + t_converted = _ffi.cast('TimestampTz', t) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) result = _lib.stbox_get_time_tile(t_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_space_tiles( - bounds: Annotated[_ffi.CData, "const STBox *"], - xsize: float, - ysize: float, - zsize: float, - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - border_inc: bool, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "STBox *"]: - bounds_converted = _ffi.cast("const STBox *", bounds) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - count_converted = _ffi.cast("int *", count) - result = _lib.stbox_space_tiles( - bounds_converted, xsize, ysize, zsize, sorigin_converted, border_inc, count_converted - ) +def stbox_space_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + bounds_converted = _ffi.cast('const STBox *', bounds) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + count = _ffi.new('int *') + result = _lib.stbox_space_tiles(bounds_converted, xsize, ysize, zsize, sorigin_converted, border_inc, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def stbox_space_time_tiles( - bounds: Annotated[_ffi.CData, "const STBox *"], - xsize: float, - ysize: float, - zsize: float, - duration: Annotated[_ffi.CData, "const Interval *"] | None, - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - torigin: int, - border_inc: bool, -) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "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("const GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count = _ffi.new("int *") - result = _lib.stbox_space_time_tiles( - bounds_converted, - xsize, - ysize, - zsize, - duration_converted, - sorigin_converted, - torigin_converted, - border_inc, - count, - ) +def stbox_space_time_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'] | None, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, '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('const GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.stbox_space_time_tiles(bounds_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, border_inc, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def stbox_time_tiles( - bounds: Annotated[_ffi.CData, "const STBox *"], - duration: Annotated[_ffi.CData, "const Interval *"], - torigin: int, - border_inc: bool, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "STBox *"]: - bounds_converted = _ffi.cast("const STBox *", bounds) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.stbox_time_tiles(bounds_converted, duration_converted, torigin_converted, border_inc, count_converted) - _check_error() - return result if result != _ffi.NULL else None - - -def tgeo_space_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - xsize: float, - ysize: float, - zsize: float, - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - bitmatrix: bool, - border_inc: bool, -) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "GSERIALIZED ***"], Annotated[_ffi.CData, "int"]]: - temp_converted = _ffi.cast("const Temporal *", temp) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - space_bins = _ffi.new("GSERIALIZED ***") - count = _ffi.new("int *") - result = _lib.tgeo_space_split( - temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, space_bins, count - ) +def stbox_time_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + bounds_converted = _ffi.cast('const STBox *', bounds) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.stbox_time_tiles(bounds_converted, duration_converted, torigin_converted, border_inc, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tgeo_space_split(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'GSERIALIZED ***'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + space_bins = _ffi.new('GSERIALIZED ***') + count = _ffi.new('int *') + result = _lib.tgeo_space_split(temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, space_bins, count) _check_error() return result if result != _ffi.NULL else None, space_bins[0], count[0] -def tgeo_space_time_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - xsize: float, - ysize: float, - zsize: float, - duration: Annotated[_ffi.CData, "const Interval *"], - sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], - torigin: int, - bitmatrix: bool, - border_inc: bool, -) -> tuple[ - Annotated[_ffi.CData, "Temporal **"], - Annotated[list, "GSERIALIZED ***"], - Annotated[list, "TimestampTz *"], - Annotated[_ffi.CData, "int"], -]: - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - space_bins = _ffi.new("GSERIALIZED ***") - time_bins = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tgeo_space_time_split( - temp_converted, - xsize, - ysize, - zsize, - duration_converted, - sorigin_converted, - torigin_converted, - bitmatrix, - border_inc, - space_bins, - time_bins, - count, - ) +def tgeo_space_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'GSERIALIZED ***'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + space_bins = _ffi.new('GSERIALIZED ***') + time_bins = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tgeo_space_time_split(temp_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, bitmatrix, border_inc, space_bins, time_bins, count) _check_error() return result if result != _ffi.NULL else None, space_bins[0], time_bins[0], count[0] -def geo_cluster_kmeans( - geoms: Annotated[list, "const GSERIALIZED **"], - ngeoms: Annotated[_ffi.CData, "uint32_t"], - k: Annotated[_ffi.CData, "uint32_t"], -) -> Annotated[_ffi.CData, "int *"]: - geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] - ngeoms_converted = _ffi.cast("uint32_t", ngeoms) - k_converted = _ffi.cast("uint32_t", k) +def geo_cluster_kmeans(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], k: Annotated[_ffi.CData, 'uint32_t']) -> Annotated[_ffi.CData, 'int *']: + geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] + ngeoms_converted = _ffi.cast('uint32_t', ngeoms) + k_converted = _ffi.cast('uint32_t', k) result = _lib.geo_cluster_kmeans(geoms_converted, ngeoms_converted, k_converted) _check_error() return result if result != _ffi.NULL else None -def geo_cluster_dbscan( - geoms: Annotated[list, "const GSERIALIZED **"], - ngeoms: Annotated[_ffi.CData, "uint32_t"], - tolerance: float, - minpoints: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "uint32_t *"]: - geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] - ngeoms_converted = _ffi.cast("uint32_t", ngeoms) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_cluster_dbscan(geoms_converted, ngeoms_converted, tolerance, minpoints, count_converted) +def geo_cluster_dbscan(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], tolerance: float, minpoints: int) -> tuple[Annotated[_ffi.CData, 'uint32_t *'], Annotated[_ffi.CData, 'int']]: + geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] + ngeoms_converted = _ffi.cast('uint32_t', ngeoms) + count = _ffi.new('int *') + result = _lib.geo_cluster_dbscan(geoms_converted, ngeoms_converted, tolerance, minpoints, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geo_cluster_intersecting( - geoms: Annotated[list, "const GSERIALIZED **"], - ngeoms: Annotated[_ffi.CData, "uint32_t"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "GSERIALIZED **"]: - geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] - ngeoms_converted = _ffi.cast("uint32_t", ngeoms) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_cluster_intersecting(geoms_converted, ngeoms_converted, count_converted) +def geo_cluster_intersecting(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: + geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] + ngeoms_converted = _ffi.cast('uint32_t', ngeoms) + count = _ffi.new('int *') + result = _lib.geo_cluster_intersecting(geoms_converted, ngeoms_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def geo_cluster_within( - geoms: Annotated[list, "const GSERIALIZED **"], - ngeoms: Annotated[_ffi.CData, "uint32_t"], - tolerance: float, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "GSERIALIZED **"]: - geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] - ngeoms_converted = _ffi.cast("uint32_t", ngeoms) - count_converted = _ffi.cast("int *", count) - result = _lib.geo_cluster_within(geoms_converted, ngeoms_converted, tolerance, count_converted) +def geo_cluster_within(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], tolerance: float) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: + geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] + ngeoms_converted = _ffi.cast('uint32_t', ngeoms) + count = _ffi.new('int *') + result = _lib.geo_cluster_within(geoms_converted, ngeoms_converted, tolerance, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def gsl_get_generation_rng() -> Annotated[_ffi.CData, "gsl_rng *"]: +def gsl_get_generation_rng() -> Annotated[_ffi.CData, 'gsl_rng *']: result = _lib.gsl_get_generation_rng() _check_error() return result if result != _ffi.NULL else None -def gsl_get_aggregation_rng() -> Annotated[_ffi.CData, "gsl_rng *"]: +def gsl_get_aggregation_rng() -> Annotated[_ffi.CData, 'gsl_rng *']: result = _lib.gsl_get_aggregation_rng() _check_error() return result if result != _ffi.NULL else None -def datum_ceil(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: - d_converted = _ffi.cast("Datum", d) +def datum_ceil(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: + d_converted = _ffi.cast('Datum', d) result = _lib.datum_ceil(d_converted) _check_error() return result if result != _ffi.NULL else None -def datum_degrees( - d: Annotated[_ffi.CData, "Datum"], normalize: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - d_converted = _ffi.cast("Datum", d) - normalize_converted = _ffi.cast("Datum", normalize) +def datum_degrees(d: Annotated[_ffi.CData, 'Datum'], normalize: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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_float_round( - value: Annotated[_ffi.CData, "Datum"], size: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - value_converted = _ffi.cast("Datum", value) - size_converted = _ffi.cast("Datum", size) +def datum_float_round(value: Annotated[_ffi.CData, 'Datum'], size: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: + value_converted = _ffi.cast('Datum', value) + size_converted = _ffi.cast('Datum', size) result = _lib.datum_float_round(value_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def datum_floor(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: - d_converted = _ffi.cast("Datum", d) +def datum_floor(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: + d_converted = _ffi.cast('Datum', d) result = _lib.datum_floor(d_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[int, "uint32"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def datum_hash(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, '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: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], seed: int -) -> Annotated[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: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], seed: int) -> Annotated[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 datum_radians(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: - d_converted = _ffi.cast("Datum", d) +def datum_radians(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: + d_converted = _ffi.cast('Datum', d) result = _lib.datum_radians(d_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_round_set(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - out_result = _ffi.new("Span *") +def floatspan_round_set(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) + out_result = _ffi.new('Span *') _lib.floatspan_round_set(s_converted, maxdd, 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 set_in(string: str, basetype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") - basetype_converted = _ffi.cast("meosType", basetype) + +def set_in(string: str, basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Set *", s) +def set_out(s: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: + 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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "Span *"]: - string_converted = string.encode("utf-8") - spantype_converted = _ffi.cast("meosType", spantype) +def span_in(string: str, spantype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Span *", s) +def span_out(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[str, 'char *']: + 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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "SpanSet *"]: - string_converted = string.encode("utf-8") - spantype_converted = _ffi.cast("meosType", spantype) +def spanset_in(string: str, spantype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_out(ss: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[str, 'char *']: + 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_make( - values: Annotated[_ffi.CData, "const Datum *"], count: int, basetype: Annotated[_ffi.CData, "meosType"], order: bool -) -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.cast("const Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) +def set_make(values: Annotated[_ffi.CData, 'const Datum *'], count: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, 'Set *']: + values_converted = _ffi.cast('const Datum *', values) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.set_make(values_converted, count, basetype_converted, order) _check_error() return result if result != _ffi.NULL else None -def set_make_exp( - values: Annotated[_ffi.CData, "const Datum *"], - count: int, - maxcount: int, - basetype: Annotated[_ffi.CData, "meosType"], - order: bool, -) -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.cast("const Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) +def set_make_exp(values: Annotated[_ffi.CData, 'const Datum *'], count: int, maxcount: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, '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, order) _check_error() return result if result != _ffi.NULL else None -def set_make_free( - values: Annotated[_ffi.CData, "Datum *"], count: int, basetype: Annotated[_ffi.CData, "meosType"], order: bool -) -> Annotated[_ffi.CData, "Set *"]: - values_converted = _ffi.cast("Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) +def set_make_free(values: Annotated[_ffi.CData, 'Datum *'], count: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, 'Set *']: + values_converted = _ffi.cast('Datum *', values) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.set_make_free(values_converted, count, basetype_converted, order) _check_error() return result if result != _ffi.NULL else None -def span_make( - lower: Annotated[_ffi.CData, "Datum"], - upper: Annotated[_ffi.CData, "Datum"], - lower_inc: bool, - upper_inc: bool, - basetype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[_ffi.CData, "Span *"]: - lower_converted = _ffi.cast("Datum", lower) - upper_converted = _ffi.cast("Datum", upper) - basetype_converted = _ffi.cast("meosType", basetype) +def span_make(lower: Annotated[_ffi.CData, 'Datum'], upper: Annotated[_ffi.CData, 'Datum'], lower_inc: bool, upper_inc: bool, basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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_set( - lower: Annotated[_ffi.CData, "Datum"], - upper: Annotated[_ffi.CData, "Datum"], - lower_inc: bool, - upper_inc: bool, - basetype: Annotated[_ffi.CData, "meosType"], - spantype: Annotated[_ffi.CData, "meosType"], - s: Annotated[_ffi.CData, "Span *"], -) -> Annotated[None, "void"]: - 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 span_set(lower: Annotated[_ffi.CData, 'Datum'], upper: Annotated[_ffi.CData, 'Datum'], lower_inc: bool, upper_inc: bool, basetype: Annotated[_ffi.CData, 'meosType'], spantype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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_make_exp( - spans: Annotated[_ffi.CData, "Span *"], count: int, maxcount: int, normalize: bool, order: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - spans_converted = _ffi.cast("Span *", spans) +def spanset_make_exp(spans: Annotated[_ffi.CData, 'Span *'], count: int, maxcount: int, normalize: bool, order: bool) -> Annotated[_ffi.CData, 'SpanSet *']: + spans_converted = _ffi.cast('Span *', spans) result = _lib.spanset_make_exp(spans_converted, count, maxcount, normalize, order) _check_error() return result if result != _ffi.NULL else None -def spanset_make_free( - spans: Annotated[_ffi.CData, "Span *"], count: int, normalize: bool, order: bool -) -> Annotated[_ffi.CData, "SpanSet *"]: - spans_converted = _ffi.cast("Span *", spans) +def spanset_make_free(spans: Annotated[_ffi.CData, 'Span *'], count: int, normalize: bool, order: bool) -> Annotated[_ffi.CData, 'SpanSet *']: + spans_converted = _ffi.cast('Span *', spans) result = _lib.spanset_make_free(spans_converted, count, normalize, order) _check_error() return result if result != _ffi.NULL else None -def set_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) +def set_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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_spanset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Set *", s) +def set_spanset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 value_set_span( - value: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], - s: Annotated[_ffi.CData, "Span *"], -) -> Annotated[None, "void"]: - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("Span *", s) +def value_set_span(value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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() -def value_set( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "Set *"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_set(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Set *']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_set(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_span( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "Span *"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_span(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Span *']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_span(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_spanset( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_spanset(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'SpanSet *']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_spanset(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Datum"]: - s_converted = _ffi.cast("const Span *", s) +def numspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 numspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def numspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, '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 set_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Datum"]: - s_converted = _ffi.cast("const Set *", s) +def set_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "int"]: - s_converted = _ffi.cast("const Set *", s) +def set_mem_size(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, '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_subspan( - s: Annotated[_ffi.CData, "const Set *"], minidx: int, maxidx: int -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("Span *") +def set_set_subspan(s: Annotated[_ffi.CData, 'const Set *'], minidx: int, maxidx: int) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('Span *') _lib.set_set_subspan(s_converted, minidx, maxidx, 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 set_set_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("Span *") + +def set_set_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('Span *') _lib.set_set_span(s_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 set_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Datum"]: - s_converted = _ffi.cast("const Set *", s) +def set_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "Datum *"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("Datum *") +def set_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, '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: @@ -15885,599 +13992,482 @@ def set_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_f return None -def set_vals(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Datum *"]: - s_converted = _ffi.cast("const Set *", s) +def set_vals(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 set_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Datum *"]: - s_converted = _ffi.cast("const Set *", s) +def set_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_lower(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_mem_size(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, '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_sps(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "const Span **"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_sps(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 spanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 datespan_set_tstzspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def datespan_set_tstzspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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_set_intspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def floatspan_set_intspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.floatspan_set_intspan(s1_converted, s2_converted) _check_error() -def intspan_set_floatspan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def intspan_set_floatspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const Set *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def numset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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_expand( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def numspan_expand(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Span *']: + s_converted = _ffi.cast('const Span *', s) + value_converted = _ffi.cast('Datum', value) result = _lib.numspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_shift_scale( - s: Annotated[_ffi.CData, "const Span *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def numspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def numspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def set_compact(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def span_expand(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_compact(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 tbox_expand_value( - box: Annotated[_ffi.CData, "const TBox *"], - value: Annotated[_ffi.CData, "Datum"], - basetyp: Annotated[_ffi.CData, "meosType"], -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - value_converted = _ffi.cast("Datum", value) - basetyp_converted = _ffi.cast("meosType", basetyp) +def tbox_expand_value(box: Annotated[_ffi.CData, 'const TBox *'], value: Annotated[_ffi.CData, 'Datum'], basetyp: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) + value_converted = _ffi.cast('Datum', value) + basetyp_converted = _ffi.cast('meosType', basetyp) result = _lib.tbox_expand_value(box_converted, value_converted, basetyp_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_textset_text_common( - s: Annotated[_ffi.CData, "const Set *"], txt: str, invert: bool -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def textcat_textset_text_common(s: Annotated[_ffi.CData, 'const Set *'], txt: str, invert: bool) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.textcat_textset_text_common(s_converted, txt_converted, invert) _check_error() return result if result != _ffi.NULL else None -def tstzspan_set_datespan( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def tstzspan_set_datespan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.tstzspan_set_datespan(s1_converted, s2_converted) _check_error() -def adjacent_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def adjacent_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 adjacent_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def adjacent_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 adjacent_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 contained_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def contained_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 contained_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def contained_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 contained_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 result if result != _ffi.NULL else None -def contains_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def contains_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def contains_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def contains_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def contains_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def contains_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 ovadj_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def ovadj_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def left_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def left_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 left_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def left_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def left_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def left_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 left_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def left_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 left_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def left_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def left_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 lfnadj_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def lfnadj_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 overleft_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def overleft_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def overleft_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def overleft_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 -def overleft_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def overleft_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 overleft_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def overleft_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def overleft_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def overleft_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 overleft_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 overright_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def overright_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def overright_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def overright_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 overright_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def overright_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 overright_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def overright_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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() return result if result != _ffi.NULL else None -def overright_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def overright_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 overright_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 right_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def right_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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 right_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def right_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 right_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def right_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, '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 right_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[bool, "bool"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, '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 right_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def right_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 right_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def right_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, '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 bbox_type(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: - bboxtype_converted = _ffi.cast("meosType", bboxtype) +def bbox_type(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + bboxtype_converted = _ffi.cast('meosType', bboxtype) result = _lib.bbox_type(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_get_size(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "size_t"]: - bboxtype_converted = _ffi.cast("meosType", bboxtype) +def bbox_get_size(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'size_t']: + bboxtype_converted = _ffi.cast('meosType', bboxtype) result = _lib.bbox_get_size(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_max_dims(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[int, "int"]: - bboxtype_converted = _ffi.cast("meosType", bboxtype) +def bbox_max_dims(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int']: + bboxtype_converted = _ffi.cast('meosType', bboxtype) result = _lib.bbox_max_dims(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_eq( - box1: Annotated[_ffi.CData, "const void *"], - box2: Annotated[_ffi.CData, "const void *"], - temptype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[bool, "bool"]: - box1_converted = _ffi.cast("const void *", box1) - box2_converted = _ffi.cast("const void *", box2) - temptype_converted = _ffi.cast("meosType", temptype) +def temporal_bbox_eq(box1: Annotated[_ffi.CData, 'const void *'], box2: Annotated[_ffi.CData, 'const void *'], temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: + box1_converted = _ffi.cast('const void *', box1) + box2_converted = _ffi.cast('const void *', box2) + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.temporal_bbox_eq(box1_converted, box2_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_cmp( - box1: Annotated[_ffi.CData, "const void *"], - box2: Annotated[_ffi.CData, "const void *"], - temptype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[int, "int"]: - box1_converted = _ffi.cast("const void *", box1) - box2_converted = _ffi.cast("const void *", box2) - temptype_converted = _ffi.cast("meosType", temptype) +def temporal_bbox_cmp(box1: Annotated[_ffi.CData, 'const void *'], box2: Annotated[_ffi.CData, 'const void *'], temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int']: + box1_converted = _ffi.cast('const void *', box1) + box2_converted = _ffi.cast('const void *', box2) + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.temporal_bbox_cmp(box1_converted, box2_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_union_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: @@ -16485,455 +14475,360 @@ def inter_span_span( return None -def intersection_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def intersection_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 intersection_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def intersection_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def intersection_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def intersection_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 intersection_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def intersection_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 intersection_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Span *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def intersection_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def intersection_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def mi_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Span *"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) - out_result = _ffi.new("Span *") +def mi_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 out_result, result if out_result != _ffi.NULL else None + return out_result, result if out_result!= _ffi.NULL else None -def minus_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) + +def minus_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 minus_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def minus_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def minus_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def minus_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 minus_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def minus_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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 minus_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def minus_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def minus_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 super_union_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Span *"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def super_union_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def union_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + value_converted = _ffi.cast('Datum', value) result = _lib.union_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def union_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def union_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def union_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def union_value_set( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Set *", s) +def union_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + value_converted = _ffi.cast('Datum', value) + s_converted = _ffi.cast('const Set *', s) result = _lib.union_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_value_span( - value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - value_converted = _ffi.cast("Datum", value) - s_converted = _ffi.cast("const Span *", s) +def union_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def union_value_spanset( - value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "SpanSet *"]: - value_converted = _ffi.cast("Datum", value) - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 distance_set_set( - s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Datum"]: - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def distance_set_value( - s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - s_converted = _ffi.cast("const Set *", s) - value_converted = _ffi.cast("Datum", value) +def distance_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 distance_span_span( - s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Datum"]: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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 distance_span_value( - s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - s_converted = _ffi.cast("const Span *", s) - value_converted = _ffi.cast("Datum", value) +def distance_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def distance_spanset_span( - ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def distance_spanset_spanset( - ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "Datum"]: - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 distance_spanset_value( - ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - value_converted = _ffi.cast("Datum", value) +def distance_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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 distance_value_value( - l: Annotated[_ffi.CData, "Datum"], r: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "Datum"]: - l_converted = _ffi.cast("Datum", l) - r_converted = _ffi.cast("Datum", r) - basetype_converted = _ffi.cast("meosType", basetype) +def distance_value_value(l: Annotated[_ffi.CData, 'Datum'], r: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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() return result if result != _ffi.NULL else None -def spanbase_extent_transfn( - state: Annotated[_ffi.CData, "Span *"], - value: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[_ffi.CData, "Span *"]: - state_converted = _ffi.cast("Span *", state) - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) +def spanbase_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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 value_union_transfn( - state: Annotated[_ffi.CData, "Set *"], - value: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) +def value_union_transfn(state: Annotated[_ffi.CData, 'Set *'], value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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 number_tstzspan_to_tbox( - d: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], - s: Annotated[_ffi.CData, "const Span *"], -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], t: int -) -> Annotated[_ffi.CData, "TBox *"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - t_converted = _ffi.cast("TimestampTz", t) +def number_timestamptz_to_tbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, '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 tbox_set( - s: Annotated[_ffi.CData, "const Span *"], - p: Annotated[_ffi.CData, "const Span *"], - box: Annotated[_ffi.CData, "TBox *"], -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Span *", s) - p_converted = _ffi.cast("const Span *", p) - box_converted = _ffi.cast("TBox *", box) +def tbox_set(s: Annotated[_ffi.CData, 'const Span *'], p: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: - box_converted = _ffi.cast("TBox *", box) +def float_set_tbox(d: float, box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + box_converted = _ffi.cast('TBox *', box) _lib.float_set_tbox(d, box_converted) _check_error() -def int_set_tbox(i: int, box: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: - box_converted = _ffi.cast("TBox *", box) +def int_set_tbox(i: int, box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + box_converted = _ffi.cast('TBox *', box) _lib.int_set_tbox(i, box_converted) _check_error() -def number_set_tbox( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - box_converted = _ffi.cast("TBox *", box) +def number_set_tbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + 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_tbox( - value: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "TBox *"]: - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) +def number_tbox(value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: + value_converted = _ffi.cast('Datum', value) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.number_tbox(value_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def numset_set_tbox( - s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("TBox *", box) +def numset_set_tbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - span_converted = _ffi.cast("const Span *", span) - box_converted = _ffi.cast("TBox *", box) +def numspan_set_tbox(span: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + span_converted = _ffi.cast('const Span *', span) + box_converted = _ffi.cast('TBox *', box) _lib.numspan_set_tbox(span_converted, box_converted) _check_error() -def timestamptz_set_tbox(t: int, box: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: - t_converted = _ffi.cast("TimestampTz", t) - box_converted = _ffi.cast("TBox *", box) +def timestamptz_set_tbox(t: int, box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + 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_tbox( - s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("TBox *", box) +def tstzset_set_tbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + s_converted = _ffi.cast('const Set *', s) + box_converted = _ffi.cast('TBox *', box) _lib.tstzset_set_tbox(s_converted, box_converted) _check_error() -def tstzspan_set_tbox( - s: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("TBox *", box) +def tstzspan_set_tbox(s: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + s_converted = _ffi.cast('const Span *', s) + box_converted = _ffi.cast('TBox *', box) _lib.tstzspan_set_tbox(s_converted, box_converted) _check_error() -def tbox_shift_scale_value( - box: Annotated[_ffi.CData, "const TBox *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "TBox *"]: - box_converted = _ffi.cast("const TBox *", box) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def tbox_shift_scale_value(box: Annotated[_ffi.CData, 'const TBox *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: + box_converted = _ffi.cast('const TBox *', box) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) result = _lib.tbox_shift_scale_value(box_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_expand( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("TBox *", box2) +def tbox_expand(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('TBox *', box2) _lib.tbox_expand(box1_converted, box2_converted) _check_error() -def inter_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: @@ -16941,540 +14836,457 @@ def inter_tbox_tbox( return None -def tboolinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tboolinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tboolseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tboolseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tboolseqset_in(string: str) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def temporal_in(string: str, temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + 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 temparr_out(temparr: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "char **"]: - temparr_converted = [_ffi.cast("Temporal *", x) for x in temparr] +def temparr_out(temparr: Annotated[list, 'Temporal **'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'char **']: + temparr_converted = [_ffi.cast('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 tfloatinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tfloatinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tfloatseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tfloatseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tfloatseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') result = _lib.tfloatseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_in(string: str, temptype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def tinstant_in(string: str, temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], maxdd: int) -> Annotated[str, "char *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_out(inst: Annotated[_ffi.CData, 'const TInstant *'], maxdd: int) -> Annotated[str, 'char *']: + 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_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tintinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tintseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tintseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tintseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tintseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') result = _lib.tintseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_in( - string: str, temptype: Annotated[_ffi.CData, "meosType"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def tsequence_in(string: str, temptype: Annotated[_ffi.CData, 'meosType'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.tsequence_in(string_converted, temptype_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_out(seq: Annotated[_ffi.CData, "const TSequence *"], maxdd: int) -> Annotated[str, "char *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_out(seq: Annotated[_ffi.CData, 'const TSequence *'], maxdd: int) -> Annotated[str, 'char *']: + 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_in( - string: str, temptype: Annotated[_ffi.CData, "meosType"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def tsequenceset_in(string: str, temptype: Annotated[_ffi.CData, 'meosType'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.tsequenceset_in(string_converted, temptype_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_out(ss: Annotated[_ffi.CData, "const TSequenceSet *"], maxdd: int) -> Annotated[str, "char *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_out(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], maxdd: int) -> Annotated[str, 'char *']: + 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_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def ttextinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def ttextseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.ttextseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def ttextseqset_in(string: str) -> Annotated[_ffi.CData, '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_from_mfjson( - mfjson: str, temptype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "Temporal *"]: - mfjson_converted = mfjson.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def temporal_from_mfjson(mfjson: str, temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, '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_from_base_temp( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - temp: Annotated[_ffi.CData, "const Temporal *"], -) -> Annotated[_ffi.CData, "Temporal *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_from_base_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_copy(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Datum"], temptype: Annotated[_ffi.CData, "meosType"], t: int -) -> Annotated[_ffi.CData, "TInstant *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_make(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, '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 tinstant_make_free( - value: Annotated[_ffi.CData, "Datum"], temptype: Annotated[_ffi.CData, "meosType"], t: int -) -> Annotated[_ffi.CData, "TInstant *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_make_free(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, '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 tsequence_copy(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_copy(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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_temp( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - seq: Annotated[_ffi.CData, "const TSequence *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_from_base_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_from_base_temp(value_converted, temptype_converted, seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzset( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - s: Annotated[_ffi.CData, "const Set *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - s_converted = _ffi.cast("const Set *", s) +def tsequence_from_base_tstzset(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequence_from_base_tstzset(value_converted, temptype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzspan( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - s: Annotated[_ffi.CData, "const Span *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequence *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - s_converted = _ffi.cast("const Span *", s) +def tsequence_from_base_tstzspan(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequence_from_base_tstzspan(value_converted, temptype_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_exp( - instants: Annotated[list, "TInstant **"], - count: int, - maxcount: int, - lower_inc: bool, - upper_inc: bool, - interp: InterpolationType, - normalize: bool, -) -> Annotated[_ffi.CData, "TSequence *"]: - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] +def tsequence_make_exp(instants: Annotated[list, 'TInstant **'], count: int, maxcount: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: + instants_converted = [_ffi.cast('TInstant *', x) for x in instants] result = _lib.tsequence_make_exp(instants_converted, count, maxcount, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_free( - instants: Annotated[list, "TInstant **"], - count: int, - lower_inc: bool, - upper_inc: bool, - interp: InterpolationType, - normalize: bool, -) -> Annotated[_ffi.CData, "TSequence *"]: - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] +def tsequence_make_free(instants: Annotated[list, 'TInstant **'], count: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: + instants_converted = [_ffi.cast('TInstant *', x) for x in instants] result = _lib.tsequence_make_free(instants_converted, count, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_copy(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_copy(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[list, "TSequenceSet **"], count: int, totalseqs: int -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seqsets_converted = [_ffi.cast("TSequenceSet *", x) for x in seqsets] +def tseqsetarr_to_tseqset(seqsets: Annotated[list, 'TSequenceSet **'], count: int, totalseqs: int) -> Annotated[_ffi.CData, '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_temp( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_from_base_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_from_base_temp(value_converted, temptype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_from_base_tstzspanset( - value: Annotated[_ffi.CData, "Datum"], - temptype: Annotated[_ffi.CData, "meosType"], - ss: Annotated[_ffi.CData, "const SpanSet *"], - interp: InterpolationType, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tsequenceset_from_base_tstzspanset(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tsequenceset_from_base_tstzspanset(value_converted, temptype_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_exp( - sequences: Annotated[list, "TSequence **"], count: int, maxcount: int, normalize: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] +def tsequenceset_make_exp(sequences: Annotated[list, 'TSequence **'], count: int, maxcount: int, normalize: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + sequences_converted = [_ffi.cast('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: Annotated[list, "TSequence **"], count: int, normalize: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] +def tsequenceset_make_free(sequences: Annotated[list, 'TSequence **'], count: int, normalize: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("Span *", s) +def temporal_set_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const TInstant *"], s: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - inst_converted = _ffi.cast("const TInstant *", inst) - s_converted = _ffi.cast("Span *", s) +def tinstant_set_tstzspan(inst: Annotated[_ffi.CData, 'const TInstant *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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_set_tbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("TBox *", box) +def tnumber_set_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('TBox *', box) _lib.tnumber_set_tbox(temp_converted, box_converted) _check_error() -def tnumberinst_set_tbox( - inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("TBox *", box) +def tnumberinst_set_tbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + inst_converted = _ffi.cast('const TInstant *', inst) + box_converted = _ffi.cast('TBox *', box) _lib.tnumberinst_set_tbox(inst_converted, box_converted) _check_error() -def tnumberseq_set_tbox( - seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("TBox *", box) +def tnumberseq_set_tbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('TBox *', box) _lib.tnumberseq_set_tbox(seq_converted, box_converted) _check_error() -def tnumberseqset_set_tbox( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "TBox *"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("TBox *", box) +def tnumberseqset_set_tbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('TBox *', box) _lib.tnumberseqset_set_tbox(ss_converted, box_converted) _check_error() -def tsequence_set_tstzspan( - seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("Span *", s) +def tsequence_set_tstzspan(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("Span *", s) +def tsequenceset_set_tstzspan(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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_inst(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_inst(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_end_inst(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Datum"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_inst_n( - temp: Annotated[_ffi.CData, "const Temporal *"], n: int -) -> Annotated[_ffi.CData, "const TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_inst_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'const TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_inst_n(temp_converted, n) _check_error() return result if result != _ffi.NULL else None -def temporal_insts_p( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "const TInstant **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_insts_p(temp_converted, count_converted) +def temporal_insts_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'const TInstant **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_insts_p(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_max_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_max_inst_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_max_inst_p(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Datum"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "size_t"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_mem_size(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_min_inst_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_min_inst_p(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Datum"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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_sequences_p( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "const TSequence **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_sequences_p(temp_converted, count_converted) +def temporal_sequences_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'const TSequence **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_sequences_p(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_set_bbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "void *"] -) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("void *", box) +def temporal_set_bbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: + 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_start_inst(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_inst(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_start_inst(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Datum"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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 temporal_values_p( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Datum *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_values_p(temp_converted, count_converted) +def temporal_values_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.temporal_values_p(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "Datum *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("Datum *") +def temporal_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'Datum *']: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('Datum *') result = _lib.temporal_value_n(temp_converted, n, out_result) _check_error() if result: @@ -17482,79 +15294,69 @@ def temporal_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> return None -def temporal_values( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Datum *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.temporal_values(temp_converted, count_converted) +def temporal_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tinstant_hash(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[int, "uint32"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_hash(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TInstant *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "const TInstant **"]: - inst_converted = _ffi.cast("const TInstant *", inst) - count_converted = _ffi.cast("int *", count) - result = _lib.tinstant_insts(inst_converted, count_converted) +def tinstant_insts(inst: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[_ffi.CData, 'const TInstant **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tinstant_set_bbox( - inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "void *"] -) -> Annotated[None, "void"]: - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("void *", box) +def tinstant_set_bbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_time(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[int, "TimestampTz *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - count_converted = _ffi.cast("int *", count) - result = _lib.tinstant_timestamps(inst_converted, count_converted) +def tinstant_timestamps(inst: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tinstant_value_p(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "Datum"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_value_p(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'Datum']: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_value_p(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_value(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "Datum"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_value(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], t: int -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], t: int) -> Annotated[_ffi.CData, '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: @@ -17562,166 +15364,154 @@ def tinstant_value_at_timestamptz( return None -def tinstant_values_p( - inst: Annotated[_ffi.CData, "const TInstant *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Datum *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - count_converted = _ffi.cast("int *", count) - result = _lib.tinstant_values_p(inst_converted, count_converted) +def tinstant_values_p(inst: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: + inst_converted = _ffi.cast('const TInstant *', inst) + count = _ffi.new('int *') + result = _lib.tinstant_values_p(inst_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnumber_set_span( - temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "Span *"] -) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("Span *", span) +def tnumber_set_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tnumberinst_valuespans(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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_avg_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_avg_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, 'double']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_avg_val(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_valuespans(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_valuespans(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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_avg_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_avg_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, 'double']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_avg_val(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_valuespans(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_valuespans(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "Interval *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_duration(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "TimestampTz"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_end_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "uint32"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_hash(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, '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_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant **"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_insts_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant **']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_insts_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_inst_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_max_inst_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_max_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "Datum"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_max_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_min_inst_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_min_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "Datum"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_min_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequence_segments(seq_converted, count_converted) +def tsequence_segments(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tsequence_seqs( - seq: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "const TSequence **"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequence_seqs(seq_converted, count_converted) +def tsequence_seqs(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'const TSequence **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tsequence_start_timestamptz(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "TimestampTz"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_start_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_time(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[int, "TimestampTz *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequence_timestamps(seq_converted, count_converted) +def tsequence_timestamps(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tsequence_value_at_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "Datum *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") +def tsequence_value_at_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -17729,139 +15519,123 @@ def tsequence_value_at_timestamptz( return None -def tsequence_values_p( - seq: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Datum *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequence_values_p(seq_converted, count_converted) +def tsequence_values_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') + result = _lib.tsequence_values_p(seq_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tsequenceset_duration( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], boundspan: bool -) -> Annotated[_ffi.CData, "Interval *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_duration(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], boundspan: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_end_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "uint32"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_hash(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"], n: int -) -> Annotated[_ffi.CData, "const TInstant *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_inst_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], n: int) -> Annotated[_ffi.CData, '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_p( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "const TInstant **"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_insts_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant **']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_insts_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_inst_p( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "const TInstant *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_max_inst_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_max_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_max_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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_p( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "const TInstant *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_min_inst_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_min_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "Datum"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_min_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_num_instants(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "int"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_num_timestamps(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequenceset_segments(ss_converted, count_converted) +def tsequenceset_segments(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tsequenceset_sequences_p( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "const TSequence **"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_sequences_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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_start_timestamptz(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "TimestampTz"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_start_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_time(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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_timestamptz_n(ss: Annotated[_ffi.CData, "const TSequenceSet *"], n: int) -> int: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - out_result = _ffi.new("TimestampTz *") +def tsequenceset_timestamptz_n(ss: Annotated[_ffi.CData, '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: @@ -17869,22 +15643,18 @@ def tsequenceset_timestamptz_n(ss: Annotated[_ffi.CData, "const TSequenceSet *"] return None -def tsequenceset_timestamps( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[int, "TimestampTz *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequenceset_timestamps(ss_converted, count_converted) +def tsequenceset_timestamps(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, '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 + return result if result != _ffi.NULL else None, count[0] -def tsequenceset_value_at_timestamptz( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "Datum *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") +def tsequenceset_value_at_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -17892,9 +15662,9 @@ def tsequenceset_value_at_timestamptz( return None -def tsequenceset_value_n(ss: Annotated[_ffi.CData, "const TSequenceSet *"], n: int) -> Annotated[_ffi.CData, "Datum *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - out_result = _ffi.new("Datum *") +def tsequenceset_value_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], n: int) -> Annotated[_ffi.CData, 'Datum *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + out_result = _ffi.new('Datum *') result = _lib.tsequenceset_value_n(ss_converted, n, out_result) _check_error() if result: @@ -17902,654 +15672,512 @@ def tsequenceset_value_n(ss: Annotated[_ffi.CData, "const TSequenceSet *"], n: i return None -def tsequenceset_values_p( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Datum *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tsequenceset_values_p(ss_converted, count_converted) +def tsequenceset_values_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') + result = _lib.tsequenceset_values_p(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_restart(temp: Annotated[_ffi.CData, "Temporal *"], count: int) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("Temporal *", temp) +def temporal_restart(temp: Annotated[_ffi.CData, 'Temporal *'], count: int) -> Annotated[None, 'void']: + temp_converted = _ffi.cast('Temporal *', temp) _lib.temporal_restart(temp_converted, count) _check_error() -def temporal_tsequence( - temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_tsequence(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_tsequence(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_tsequenceset( - temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_tsequenceset(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_tsequenceset(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_shift_time( - inst: Annotated[_ffi.CData, "const TInstant *"], interv: Annotated[_ffi.CData, "const Interval *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - interv_converted = _ffi.cast("const Interval *", interv) +def tinstant_shift_time(inst: Annotated[_ffi.CData, 'const TInstant *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_to_tsequence(inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_to_tsequence(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequence_free( - inst: Annotated[_ffi.CData, "TInstant *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequence *"]: - inst_converted = _ffi.cast("TInstant *", inst) +def tinstant_to_tsequence_free(inst: Annotated[_ffi.CData, 'TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + inst_converted = _ffi.cast('TInstant *', inst) result = _lib.tinstant_to_tsequence_free(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequenceset( - inst: Annotated[_ffi.CData, "const TInstant *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_to_tsequenceset(inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_to_tsequenceset(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tnumber_shift_scale_value( - temp: Annotated[_ffi.CData, "const Temporal *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def tnumber_shift_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], shift: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - shift_converted = _ffi.cast("Datum", shift) +def tnumberinst_shift_value(inst: Annotated[_ffi.CData, 'const TInstant *'], shift: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], - shift: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) +def tnumberseq_shift_scale_value(seq: Annotated[_ffi.CData, 'const TSequence *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], - start: Annotated[_ffi.CData, "Datum"], - width: Annotated[_ffi.CData, "Datum"], - hasshift: bool, - haswidth: bool, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - start_converted = _ffi.cast("Datum", start) - width_converted = _ffi.cast("Datum", width) +def tnumberseqset_shift_scale_value(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], start: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, '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_restart(seq: Annotated[_ffi.CData, "TSequence *"], count: int) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("TSequence *", seq) +def tsequence_restart(seq: Annotated[_ffi.CData, 'TSequence *'], count: int) -> Annotated[None, 'void']: + seq_converted = _ffi.cast('TSequence *', seq) _lib.tsequence_restart(seq_converted, count) _check_error() -def tsequence_set_interp( - seq: Annotated[_ffi.CData, "const TSequence *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_set_interp(seq: Annotated[_ffi.CData, 'const TSequence *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_set_interp(seq_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_shift_scale_time( - seq: Annotated[_ffi.CData, "const TSequence *"], - shift: Annotated[_ffi.CData, "const Interval *"], - duration: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - shift_converted = _ffi.cast("const Interval *", shift) - duration_converted = _ffi.cast("const Interval *", duration) +def tsequence_shift_scale_time(seq: Annotated[_ffi.CData, 'const TSequence *'], shift: Annotated[_ffi.CData, 'const Interval *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], from_: int, to: int, lower_inc: bool, upper_inc: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_subseq(seq: Annotated[_ffi.CData, 'const TSequence *'], from_: int, to: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TInstant *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tinstant(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tsequenceset(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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_free( - seq: Annotated[_ffi.CData, "TSequence *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seq_converted = _ffi.cast("TSequence *", seq) +def tsequence_to_tsequenceset_free(seq: Annotated[_ffi.CData, 'TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tsequenceset_interp(seq: Annotated[_ffi.CData, 'const TSequence *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_to_tsequenceset_interp(seq_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restart(ss: Annotated[_ffi.CData, "TSequenceSet *"], count: int) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("TSequenceSet *", ss) +def tsequenceset_restart(ss: Annotated[_ffi.CData, 'TSequenceSet *'], count: int) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('TSequenceSet *', ss) _lib.tsequenceset_restart(ss_converted, count) _check_error() -def tsequenceset_set_interp( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], interp: InterpolationType -) -> Annotated[_ffi.CData, "Temporal *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_set_interp(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_set_interp(ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_shift_scale_time( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], - start: Annotated[_ffi.CData, "const Interval *"], - duration: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - start_converted = _ffi.cast("const Interval *", start) - duration_converted = _ffi.cast("const Interval *", duration) +def tsequenceset_shift_scale_time(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], start: Annotated[_ffi.CData, 'const Interval *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequence *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_discrete(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_linear(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_step(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TInstant *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_tinstant(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_tsequence(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_merge(inst1: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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: Annotated[list, "TInstant **"], count: int) -> Annotated[_ffi.CData, "Temporal *"]: - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] +def tinstant_merge_array(instants: Annotated[list, 'TInstant **'], count: int) -> Annotated[_ffi.CData, 'Temporal *']: + instants_converted = [_ffi.cast('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: Annotated[_ffi.CData, "TSequence *"], - inst: Annotated[_ffi.CData, "const TInstant *"], - maxdist: float, - maxt: Annotated[_ffi.CData, "const Interval *"], - expand: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("TSequence *", seq) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) +def tsequence_append_tinstant(seq: Annotated[_ffi.CData, 'TSequence *'], inst: Annotated[_ffi.CData, 'const TInstant *'], maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'], expand: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"], expand: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_append_tsequence(seq1: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: + seq1_converted = _ffi.cast('const 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: Annotated[_ffi.CData, "const TSequence *"], t: int, connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tsequence_delete_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Set *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Set *", s) +def tsequence_delete_tstzset(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Set *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Span *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Span *", s) +def tsequence_delete_tstzspan(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Span *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], ss: Annotated[_ffi.CData, "const SpanSet *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tsequence_delete_tstzspanset(seq: Annotated[_ffi.CData, 'const TSequence *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"], connect: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_insert(seq1: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *'], connect: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_merge(seq1: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[list, "TSequence **"], count: int -) -> Annotated[_ffi.CData, "Temporal *"]: - sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] +def tsequence_merge_array(sequences: Annotated[list, 'TSequence **'], count: int) -> Annotated[_ffi.CData, 'Temporal *']: + sequences_converted = [_ffi.cast('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: Annotated[_ffi.CData, "TSequenceSet *"], - inst: Annotated[_ffi.CData, "const TInstant *"], - maxdist: float, - maxt: Annotated[_ffi.CData, "const Interval *"], - expand: bool, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("TSequenceSet *", ss) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) +def tsequenceset_append_tinstant(ss: Annotated[_ffi.CData, 'TSequenceSet *'], inst: Annotated[_ffi.CData, 'const TInstant *'], maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'], expand: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "TSequenceSet *"], seq: Annotated[_ffi.CData, "const TSequence *"], expand: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("TSequenceSet *", ss) - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequenceset_append_tsequence(ss: Annotated[_ffi.CData, 'TSequenceSet *'], seq: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], t: int -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_delete_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_delete_tstzset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def tsequenceset_delete_tstzspan(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], ps: Annotated[_ffi.CData, "const SpanSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - ps_converted = _ffi.cast("const SpanSet *", ps) +def tsequenceset_delete_tstzspanset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], ps: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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 tsequenceset_insert( - ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_insert(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 tsequenceset_merge( - ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_merge(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[list, "TSequenceSet **"], count: int -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seqsets_converted = [_ffi.cast("TSequenceSet *", x) for x in seqsets] +def tsequenceset_merge_array(seqsets: Annotated[list, 'TSequenceSet **'], count: int) -> Annotated[_ffi.CData, 'TSequenceSet *']: + seqsets_converted = [_ffi.cast('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 tsequence_expand_bbox( - seq: Annotated[_ffi.CData, "TSequence *"], inst: Annotated[_ffi.CData, "const TInstant *"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("TSequence *", seq) - inst_converted = _ffi.cast("const TInstant *", inst) +def tsequence_expand_bbox(seq: Annotated[_ffi.CData, 'TSequence *'], inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[None, 'void']: + 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_set_bbox( - seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "void *"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("void *", box) +def tsequence_set_bbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('void *', box) _lib.tsequence_set_bbox(seq_converted, box_converted) _check_error() -def tsequenceset_expand_bbox( - ss: Annotated[_ffi.CData, "TSequenceSet *"], seq: Annotated[_ffi.CData, "const TSequence *"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("TSequenceSet *", ss) - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequenceset_expand_bbox(ss: Annotated[_ffi.CData, 'TSequenceSet *'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('TSequenceSet *', ss) + seq_converted = _ffi.cast('const TSequence *', seq) _lib.tsequenceset_expand_bbox(ss_converted, seq_converted) _check_error() -def tsequenceset_set_bbox( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "void *"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("void *", box) +def tsequenceset_set_bbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('void *', box) _lib.tsequenceset_set_bbox(ss_converted, box_converted) _check_error() -def tcontseq_after_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tcontseq_after_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tcontseq_after_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tcontseq_before_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tcontseq_before_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tcontseq_before_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tcontseq_restrict_minmax( - seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tcontseq_restrict_minmax(seq: Annotated[_ffi.CData, 'const TSequence *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, '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 tdiscseq_after_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tdiscseq_after_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tdiscseq_after_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tdiscseq_before_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tdiscseq_before_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tdiscseq_before_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tdiscseq_restrict_minmax( - seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tdiscseq_restrict_minmax(seq: Annotated[_ffi.CData, 'const TSequence *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, '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 temporal_bbox_restrict_set( - temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_bbox_restrict_set(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Temporal *"], min: bool, atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_restrict_minmax(temp: Annotated[_ffi.CData, 'const Temporal *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, '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_timestamptz( - temp: Annotated[_ffi.CData, "const Temporal *"], t: int, atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_restrict_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_restrict_tstzset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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_tstzspan( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_restrict_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_restrict_tstzspanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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_value( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_restrict_value(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_restrict_values(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "Datum *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") +def temporal_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, '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: @@ -18557,1125 +16185,859 @@ def temporal_value_at_timestamptz( return None -def tinstant_after_timestamptz( - inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_after_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TInstant *']: + inst_converted = _ffi.cast('const TInstant *', inst) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tinstant_after_timestamptz(inst_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tinstant_before_timestamptz( - inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_before_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TInstant *']: + inst_converted = _ffi.cast('const TInstant *', inst) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tinstant_before_timestamptz(inst_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzspan( - inst: Annotated[_ffi.CData, "const TInstant *"], period: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - period_converted = _ffi.cast("const Span *", period) +def tinstant_restrict_tstzspan(inst: Annotated[_ffi.CData, 'const TInstant *'], period: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tinstant_restrict_tstzspanset(inst: Annotated[_ffi.CData, 'const TInstant *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], t: int, atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_restrict_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - s_converted = _ffi.cast("const Set *", s) +def tinstant_restrict_tstzset(inst: Annotated[_ffi.CData, 'const TInstant *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_restrict_value(inst: Annotated[_ffi.CData, 'const TInstant *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], set: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - set_converted = _ffi.cast("const Set *", set) +def tinstant_restrict_values(inst: Annotated[_ffi.CData, 'const TInstant *'], set: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_restrict_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_restrict_spanset(temp: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - span_converted = _ffi.cast("const Span *", span) +def tnumberinst_restrict_span(inst: Annotated[_ffi.CData, 'const TInstant *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumberinst_restrict_spanset(inst: Annotated[_ffi.CData, 'const TInstant *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - span_converted = _ffi.cast("const Span *", span) +def tnumberseqset_restrict_span(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], spanset: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - spanset_converted = _ffi.cast("const SpanSet *", spanset) +def tnumberseqset_restrict_spanset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], spanset: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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 tsequence_at_timestamptz( - seq: Annotated[_ffi.CData, "const TSequence *"], t: int -) -> Annotated[_ffi.CData, "TInstant *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tsequence_at_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int) -> Annotated[_ffi.CData, '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_tstzspan( - seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Span *", s) +def tsequence_restrict_tstzspan(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tsequence_restrict_tstzspanset(seq: Annotated[_ffi.CData, 'const TSequence *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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 tsequenceset_after_timestamptz( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_after_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequenceset_after_timestamptz(ss_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_before_timestamptz( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_before_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequenceset_before_timestamptz(ss_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_minmax( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], min: bool, atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_restrict_minmax(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def tsequenceset_restrict_tstzspan(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], ps: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - ps_converted = _ffi.cast("const SpanSet *", ps) +def tsequenceset_restrict_tstzspanset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], ps: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_restrict_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_restrict_tstzset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_restrict_value(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_restrict_values(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, '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 tinstant_cmp( - inst1: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] -) -> Annotated[int, "int"]: - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_cmp(inst1: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] -) -> Annotated[bool, "bool"]: - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_eq(inst1: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] -) -> Annotated[int, "int"]: - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_cmp(seq1: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] -) -> Annotated[bool, "bool"]: - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_eq(seq1: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] -) -> Annotated[int, "int"]: - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_cmp(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, '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: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] -) -> Annotated[bool, "bool"]: - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_eq(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[bool, '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 always_eq_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_eq_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_eq_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 always_ne_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ne_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_ne_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 always_ge_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ge_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_ge_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_ge_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 always_gt_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_gt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_gt_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_gt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 always_le_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_le_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_le_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_le_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 always_lt_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_lt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 always_lt_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def always_lt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_eq_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_eq_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_eq_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_ne_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ne_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_ne_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_ge_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ge_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_ge_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_ge_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_gt_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_gt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_gt_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_gt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_le_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_le_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_le_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_le_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 ever_lt_base_temporal( - value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - value_converted = _ffi.cast("Datum", value) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_lt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, '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 ever_lt_temporal_base( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def ever_lt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, '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 tnumberinst_abs(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tnumberinst_abs(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_abs(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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 tnumberseq_angular_difference( - seq: Annotated[_ffi.CData, "const TSequence *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_angular_difference(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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 tnumberseq_delta_value(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_delta_value(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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_abs(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_abs(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 tnumberseqset_angular_difference( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequence *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_angular_difference(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 tnumberseqset_delta_value( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_delta_value(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 tdistance_tnumber_number( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def tdistance_tnumber_number(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.tdistance_tnumber_number(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tbox_tbox( - box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[float, "double"]: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def nad_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, '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_tnumber_number( - temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def nad_tnumber_number(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.nad_tnumber_number(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_tbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def nad_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, '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_tnumber_tnumber( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: + 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 -def tnumberseq_integral(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_integral(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_twavg(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_integral(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_twavg(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, '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 temporal_compact(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_compact(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_compact(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_compact(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 temporal_skiplist_make() -> Annotated[_ffi.CData, "SkipList *"]: +def temporal_skiplist_make() -> Annotated[_ffi.CData, 'SkipList *']: result = _lib.temporal_skiplist_make() _check_error() return result if result != _ffi.NULL else None -def skiplist_search( - list: Annotated[_ffi.CData, "SkipList *"], - key: Annotated[_ffi.CData, "void *"], - value: Annotated[_ffi.CData, "void *"], -) -> Annotated[int, "int"]: - list_converted = _ffi.cast("SkipList *", list) - key_converted = _ffi.cast("void *", key) - value_converted = _ffi.cast("void *", value) +def skiplist_search(list: Annotated[_ffi.CData, 'SkipList *'], key: Annotated[_ffi.CData, 'void *'], value: Annotated[_ffi.CData, 'void *']) -> Annotated[int, 'int']: + list_converted = _ffi.cast('SkipList *', list) + key_converted = _ffi.cast('void *', key) + value_converted = _ffi.cast('void *', value) result = _lib.skiplist_search(list_converted, key_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def skiplist_free(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[None, "void"]: - list_converted = _ffi.cast("SkipList *", list) +def skiplist_free(list: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[None, 'void']: + list_converted = _ffi.cast('SkipList *', list) _lib.skiplist_free(list_converted) _check_error() -def skiplist_splice( - list: Annotated[_ffi.CData, "SkipList *"], - keys: Annotated[list, "void **"], - values: Annotated[list, "void **"], - count: int, - func: Annotated[_ffi.CData, "datum_func2"], - crossings: bool, - sktype: Annotated[_ffi.CData, "SkipListType"], -) -> Annotated[None, "void"]: - list_converted = _ffi.cast("SkipList *", list) - keys_converted = [_ffi.cast("void *", x) for x in keys] - values_converted = [_ffi.cast("void *", x) for x in values] - func_converted = _ffi.cast("datum_func2", func) - sktype_converted = _ffi.cast("SkipListType", sktype) - _lib.skiplist_splice( - list_converted, keys_converted, values_converted, count, func_converted, crossings, sktype_converted - ) +def skiplist_splice(list: Annotated[_ffi.CData, 'SkipList *'], keys: Annotated[list, 'void **'], values: Annotated[list, 'void **'], count: int, func: Annotated[_ffi.CData, 'datum_func2'], crossings: bool, sktype: Annotated[_ffi.CData, 'SkipListType']) -> Annotated[None, 'void']: + list_converted = _ffi.cast('SkipList *', list) + keys_converted = [_ffi.cast('void *', x) for x in keys] + values_converted = [_ffi.cast('void *', x) for x in values] + func_converted = _ffi.cast('datum_func2', func) + sktype_converted = _ffi.cast('SkipListType', sktype) + _lib.skiplist_splice(list_converted, keys_converted, values_converted, count, func_converted, crossings, sktype_converted) _check_error() -def temporal_skiplist_splice( - list: Annotated[_ffi.CData, "SkipList *"], - values: Annotated[list, "void **"], - count: int, - func: Annotated[_ffi.CData, "datum_func2"], - crossings: bool, -) -> Annotated[None, "void"]: - list_converted = _ffi.cast("SkipList *", list) - values_converted = [_ffi.cast("void *", x) for x in values] - func_converted = _ffi.cast("datum_func2", func) +def temporal_skiplist_splice(list: Annotated[_ffi.CData, 'SkipList *'], values: Annotated[list, 'void **'], count: int, func: Annotated[_ffi.CData, 'datum_func2'], crossings: bool) -> Annotated[None, 'void']: + list_converted = _ffi.cast('SkipList *', list) + values_converted = [_ffi.cast('void *', x) for x in values] + func_converted = _ffi.cast('datum_func2', func) _lib.temporal_skiplist_splice(list_converted, values_converted, count, func_converted, crossings) _check_error() -def skiplist_values(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "void **"]: - list_converted = _ffi.cast("SkipList *", list) +def skiplist_values(list: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, 'void **']: + list_converted = _ffi.cast('SkipList *', list) result = _lib.skiplist_values(list_converted) _check_error() return result if result != _ffi.NULL else None -def skiplist_keys_values( - list: Annotated[_ffi.CData, "SkipList *"], values: Annotated[list, "void **"] -) -> Annotated[_ffi.CData, "void **"]: - list_converted = _ffi.cast("SkipList *", list) - values_converted = [_ffi.cast("void *", x) for x in values] +def skiplist_keys_values(list: Annotated[_ffi.CData, 'SkipList *'], values: Annotated[list, 'void **']) -> Annotated[_ffi.CData, 'void **']: + list_converted = _ffi.cast('SkipList *', list) + values_converted = [_ffi.cast('void *', x) for x in values] result = _lib.skiplist_keys_values(list_converted, values_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_app_tinst_transfn( - state: Annotated[_ffi.CData, "Temporal *"], - inst: Annotated[_ffi.CData, "const TInstant *"], - interp: InterpolationType, - maxdist: float, - maxt: Annotated[_ffi.CData, "const Interval *"], -) -> Annotated[_ffi.CData, "Temporal *"]: - state_converted = _ffi.cast("Temporal *", state) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) +def temporal_app_tinst_transfn(state: Annotated[_ffi.CData, 'Temporal *'], inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType, maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Temporal *']: + state_converted = _ffi.cast('Temporal *', state) + inst_converted = _ffi.cast('const TInstant *', inst) + maxt_converted = _ffi.cast('const Interval *', maxt) result = _lib.temporal_app_tinst_transfn(state_converted, inst_converted, interp, maxdist, maxt_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_app_tseq_transfn( - state: Annotated[_ffi.CData, "Temporal *"], seq: Annotated[_ffi.CData, "const TSequence *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - state_converted = _ffi.cast("Temporal *", state) - seq_converted = _ffi.cast("const TSequence *", seq) +def temporal_app_tseq_transfn(state: Annotated[_ffi.CData, 'Temporal *'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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 span_bins( - s: Annotated[_ffi.CData, "const Span *"], - size: Annotated[_ffi.CData, "Datum"], - origin: Annotated[_ffi.CData, "Datum"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - s_converted = _ffi.cast("const Span *", s) - size_converted = _ffi.cast("Datum", size) - origin_converted = _ffi.cast("Datum", origin) - count_converted = _ffi.cast("int *", count) - result = _lib.span_bins(s_converted, size_converted, origin_converted, count_converted) +def span_bins(s: Annotated[_ffi.CData, 'const Span *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + s_converted = _ffi.cast('const Span *', s) + size_converted = _ffi.cast('Datum', size) + origin_converted = _ffi.cast('Datum', origin) + count = _ffi.new('int *') + result = _lib.span_bins(s_converted, size_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 spanset_bins( - ss: Annotated[_ffi.CData, "const SpanSet *"], - size: Annotated[_ffi.CData, "Datum"], - origin: Annotated[_ffi.CData, "Datum"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - ss_converted = _ffi.cast("const SpanSet *", ss) - size_converted = _ffi.cast("Datum", size) - origin_converted = _ffi.cast("Datum", origin) - count_converted = _ffi.cast("int *", count) - result = _lib.spanset_bins(ss_converted, size_converted, origin_converted, count_converted) +def spanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const SpanSet *', ss) + size_converted = _ffi.cast('Datum', size) + origin_converted = _ffi.cast('Datum', origin) + count = _ffi.new('int *') + result = _lib.spanset_bins(ss_converted, size_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 tnumber_value_bins( - temp: Annotated[_ffi.CData, "const Temporal *"], - size: Annotated[_ffi.CData, "Datum"], - origin: Annotated[_ffi.CData, "Datum"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Span *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - size_converted = _ffi.cast("Datum", size) - origin_converted = _ffi.cast("Datum", origin) - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_value_bins(temp_converted, size_converted, origin_converted, count_converted) +def tnumber_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + size_converted = _ffi.cast('Datum', size) + origin_converted = _ffi.cast('Datum', origin) + count = _ffi.new('int *') + result = _lib.tnumber_value_bins(temp_converted, size_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 tnumber_value_time_boxes( - temp: Annotated[_ffi.CData, "const Temporal *"], - vsize: Annotated[_ffi.CData, "Datum"], - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: Annotated[_ffi.CData, "Datum"], - torigin: int, - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "TBox *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - vsize_converted = _ffi.cast("Datum", vsize) - duration_converted = _ffi.cast("const Interval *", duration) - vorigin_converted = _ffi.cast("Datum", vorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_value_time_boxes( - temp_converted, vsize_converted, duration_converted, vorigin_converted, torigin_converted, count_converted - ) +def tnumber_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + vsize_converted = _ffi.cast('Datum', vsize) + duration_converted = _ffi.cast('const Interval *', duration) + vorigin_converted = _ffi.cast('Datum', vorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.tnumber_value_time_boxes(temp_converted, vsize_converted, duration_converted, vorigin_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 tnumber_value_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - vsize: Annotated[_ffi.CData, "Datum"], - vorigin: Annotated[_ffi.CData, "Datum"], - bins: Annotated[list, "Datum **"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Temporal **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - vsize_converted = _ffi.cast("Datum", vsize) - vorigin_converted = _ffi.cast("Datum", vorigin) - bins_converted = [_ffi.cast("Datum *", x) for x in bins] - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_value_split( - temp_converted, vsize_converted, vorigin_converted, bins_converted, count_converted - ) +def tnumber_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: Annotated[_ffi.CData, 'Datum'], vorigin: Annotated[_ffi.CData, 'Datum'], bins: Annotated[list, 'Datum **']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + vsize_converted = _ffi.cast('Datum', vsize) + vorigin_converted = _ffi.cast('Datum', vorigin) + bins_converted = [_ffi.cast('Datum *', x) for x in bins] + count = _ffi.new('int *') + result = _lib.tnumber_value_split(temp_converted, vsize_converted, vorigin_converted, bins_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tbox_get_value_time_tile( - value: Annotated[_ffi.CData, "Datum"], - t: int, - vsize: Annotated[_ffi.CData, "Datum"], - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: Annotated[_ffi.CData, "Datum"], - torigin: int, - basetype: Annotated[_ffi.CData, "meosType"], - spantype: Annotated[_ffi.CData, "meosType"], -) -> Annotated[_ffi.CData, "TBox *"]: - value_converted = _ffi.cast("Datum", value) - t_converted = _ffi.cast("TimestampTz", t) - vsize_converted = _ffi.cast("Datum", vsize) - duration_converted = _ffi.cast("const Interval *", duration) - vorigin_converted = _ffi.cast("Datum", vorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - basetype_converted = _ffi.cast("meosType", basetype) - spantype_converted = _ffi.cast("meosType", spantype) - result = _lib.tbox_get_value_time_tile( - value_converted, - t_converted, - vsize_converted, - duration_converted, - vorigin_converted, - torigin_converted, - basetype_converted, - spantype_converted, - ) +def tbox_get_value_time_tile(value: Annotated[_ffi.CData, 'Datum'], t: int, vsize: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int, basetype: Annotated[_ffi.CData, 'meosType'], spantype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: + value_converted = _ffi.cast('Datum', value) + t_converted = _ffi.cast('TimestampTz', t) + vsize_converted = _ffi.cast('Datum', vsize) + duration_converted = _ffi.cast('const Interval *', duration) + vorigin_converted = _ffi.cast('Datum', vorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + basetype_converted = _ffi.cast('meosType', basetype) + spantype_converted = _ffi.cast('meosType', spantype) + result = _lib.tbox_get_value_time_tile(value_converted, t_converted, vsize_converted, duration_converted, vorigin_converted, torigin_converted, basetype_converted, spantype_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_value_time_split( - temp: Annotated[_ffi.CData, "const Temporal *"], - size: Annotated[_ffi.CData, "Datum"], - duration: Annotated[_ffi.CData, "const Interval *"], - vorigin: Annotated[_ffi.CData, "Datum"], - torigin: int, - value_bins: Annotated[list, "Datum **"], - time_bins: Annotated[list, "TimestampTz **"], - count: Annotated[_ffi.CData, "int *"], -) -> Annotated[_ffi.CData, "Temporal **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - size_converted = _ffi.cast("Datum", size) - duration_converted = _ffi.cast("const Interval *", duration) - vorigin_converted = _ffi.cast("Datum", vorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - value_bins_converted = [_ffi.cast("Datum *", x) for x in value_bins] - time_bins_converted = [_ffi.cast("TimestampTz *", x) for x in time_bins] - count_converted = _ffi.cast("int *", count) - result = _lib.tnumber_value_time_split( - temp_converted, - size_converted, - duration_converted, - vorigin_converted, - torigin_converted, - value_bins_converted, - time_bins_converted, - count_converted, - ) +def tnumber_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int, value_bins: Annotated[list, 'Datum **'], time_bins: Annotated[list, 'TimestampTz **']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + size_converted = _ffi.cast('Datum', size) + duration_converted = _ffi.cast('const Interval *', duration) + vorigin_converted = _ffi.cast('Datum', vorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + value_bins_converted = [_ffi.cast('Datum *', x) for x in value_bins] + time_bins_converted = [_ffi.cast('TimestampTz *', x) for x in time_bins] + count = _ffi.new('int *') + result = _lib.tnumber_value_time_split(temp_converted, size_converted, duration_converted, vorigin_converted, torigin_converted, value_bins_converted, time_bins_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def proj_get_context() -> Annotated[_ffi.CData, "PJ_CONTEXT *"]: +def proj_get_context() -> Annotated[_ffi.CData, 'PJ_CONTEXT *']: result = _lib.proj_get_context() _check_error() return result if result != _ffi.NULL else None -def datum_geo_round( - value: Annotated[_ffi.CData, "Datum"], size: Annotated[_ffi.CData, "Datum"] -) -> Annotated[_ffi.CData, "Datum"]: - value_converted = _ffi.cast("Datum", value) - size_converted = _ffi.cast("Datum", size) +def datum_geo_round(value: Annotated[_ffi.CData, 'Datum'], size: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: + value_converted = _ffi.cast('Datum', value) + size_converted = _ffi.cast('Datum', size) result = _lib.datum_geo_round(value_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def point_round(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], maxdd: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def point_round(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], maxdd: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.point_round(gs_converted, maxdd) _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: Annotated[_ffi.CData, "const Span *"], - box: Annotated[_ffi.CData, "STBox *"], -) -> Annotated[None, "void"]: - srid_converted = _ffi.cast("int32", srid) - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("STBox *", box) +def stbox_set(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + 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 gbox_set_stbox( - box: Annotated[_ffi.CData, "const GBOX *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[_ffi.CData, "STBox *"]: - box_converted = _ffi.cast("const GBOX *", box) - srid_converted = _ffi.cast("int32_t", srid) - out_result = _ffi.new("STBox *") +def gbox_set_stbox(box: Annotated[_ffi.CData, 'const GBOX *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: + box_converted = _ffi.cast('const GBOX *', box) + srid_converted = _ffi.cast('int32_t', srid) + out_result = _ffi.new('STBox *') _lib.gbox_set_stbox(box_converted, srid_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 geo_set_stbox( - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[bool, "bool"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - box_converted = _ffi.cast("STBox *", box) + +def geo_set_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const Datum *"], count: int, box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - values_converted = _ffi.cast("const Datum *", values) - box_converted = _ffi.cast("STBox *", box) +def geoarr_set_stbox(values: Annotated[_ffi.CData, 'const Datum *'], count: int, box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + 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 spatial_set_stbox( - d: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], - box: Annotated[_ffi.CData, "STBox *"], -) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - box_converted = _ffi.cast("STBox *", box) +def spatial_set_stbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[bool, 'bool']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + box_converted = _ffi.cast('STBox *', box) result = _lib.spatial_set_stbox(d_converted, basetype_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_set_stbox( - set: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - set_converted = _ffi.cast("const Set *", set) - box_converted = _ffi.cast("STBox *", box) +def spatialset_set_stbox(set: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + set_converted = _ffi.cast('const Set *', set) + box_converted = _ffi.cast('STBox *', box) _lib.spatialset_set_stbox(set_converted, box_converted) _check_error() -def stbox_set_box3d( - box: Annotated[_ffi.CData, "const STBox *"], box3d: Annotated[_ffi.CData, "BOX3D *"] -) -> Annotated[None, "void"]: - box_converted = _ffi.cast("const STBox *", box) - box3d_converted = _ffi.cast("BOX3D *", box3d) +def stbox_set_box3d(box: Annotated[_ffi.CData, 'const STBox *'], box3d: Annotated[_ffi.CData, 'BOX3D *']) -> Annotated[None, 'void']: + 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: Annotated[_ffi.CData, "const STBox *"], gbox: Annotated[_ffi.CData, "GBOX *"] -) -> Annotated[None, "void"]: - box_converted = _ffi.cast("const STBox *", box) - gbox_converted = _ffi.cast("GBOX *", gbox) +def stbox_set_gbox(box: Annotated[_ffi.CData, 'const STBox *'], gbox: Annotated[_ffi.CData, 'GBOX *']) -> Annotated[None, 'void']: + box_converted = _ffi.cast('const STBox *', box) + gbox_converted = _ffi.cast('GBOX *', gbox) _lib.stbox_set_gbox(box_converted, gbox_converted) _check_error() -def tstzset_set_stbox( - s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("STBox *", box) +def tstzset_set_stbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + s_converted = _ffi.cast('const Set *', s) + box_converted = _ffi.cast('STBox *', box) _lib.tstzset_set_stbox(s_converted, box_converted) _check_error() -def tstzspan_set_stbox( - s: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("STBox *", box) +def tstzspan_set_stbox(s: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + s_converted = _ffi.cast('const Span *', s) + box_converted = _ffi.cast('STBox *', box) _lib.tstzspan_set_stbox(s_converted, box_converted) _check_error() -def tstzspanset_set_stbox( - s: Annotated[_ffi.CData, "const SpanSet *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - s_converted = _ffi.cast("const SpanSet *", s) - box_converted = _ffi.cast("STBox *", box) +def tstzspanset_set_stbox(s: Annotated[_ffi.CData, 'const SpanSet *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + s_converted = _ffi.cast('const SpanSet *', s) + box_converted = _ffi.cast('STBox *', box) _lib.tstzspanset_set_stbox(s_converted, box_converted) _check_error() -def stbox_expand( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("STBox *", box2) +def stbox_expand(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('STBox *', box2) _lib.stbox_expand(box1_converted, box2_converted) _check_error() -def inter_stbox_stbox( - box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: @@ -19683,970 +17045,842 @@ def inter_stbox_stbox( return None -def stbox_geo(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - box_converted = _ffi.cast("const STBox *", box) +def stbox_geo(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_geo(box_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tgeogpointinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tgeogpointseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tgeogpointseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tgeogpointseqset_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tgeompointinst_in(string: str) -> Annotated[_ffi.CData, '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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tgeompointseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tgeompointseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tgeompointseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') result = _lib.tgeompointseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeographyinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tgeographyinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: + string_converted = string.encode('utf-8') result = _lib.tgeographyinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeographyseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tgeographyseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tgeographyseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeographyseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tgeographyseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') result = _lib.tgeographyseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometryinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: - string_converted = string.encode("utf-8") +def tgeometryinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: + string_converted = string.encode('utf-8') result = _lib.tgeometryinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometryseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: - string_converted = string.encode("utf-8") +def tgeometryseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: + string_converted = string.encode('utf-8') result = _lib.tgeometryseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeometryseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: - string_converted = string.encode("utf-8") +def tgeometryseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: + string_converted = string.encode('utf-8') result = _lib.tgeometryseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_set_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("STBox *", box) +def tspatial_set_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('STBox *', box) _lib.tspatial_set_stbox(temp_converted, box_converted) _check_error() -def tgeoinst_set_stbox( - inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("STBox *", box) +def tgeoinst_set_stbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + inst_converted = _ffi.cast('const TInstant *', inst) + box_converted = _ffi.cast('STBox *', box) _lib.tgeoinst_set_stbox(inst_converted, box_converted) _check_error() -def tspatialseq_set_stbox( - seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("STBox *", box) +def tspatialseq_set_stbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('STBox *', box) _lib.tspatialseq_set_stbox(seq_converted, box_converted) _check_error() -def tspatialseqset_set_stbox( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "STBox *"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("STBox *", box) +def tspatialseqset_set_stbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('STBox *', box) _lib.tspatialseqset_set_stbox(ss_converted, box_converted) _check_error() -def tgeo_restrict_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], - atfunc: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tgeo_restrict_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tgeo_restrict_geom(temp_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeo_restrict_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], - box: Annotated[_ffi.CData, "const STBox *"], - border_inc: bool, - atfunc: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tgeo_restrict_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeo_restrict_stbox(temp_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_restrict_geom( - inst: Annotated[_ffi.CData, "const TInstant *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], - atfunc: bool, -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tgeoinst_restrict_geom(inst: Annotated[_ffi.CData, 'const TInstant *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: + inst_converted = _ffi.cast('const TInstant *', inst) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tgeoinst_restrict_geom(inst_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_restrict_stbox( - inst: Annotated[_ffi.CData, "const TInstant *"], - box: Annotated[_ffi.CData, "const STBox *"], - border_inc: bool, - atfunc: bool, -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("const STBox *", box) +def tgeoinst_restrict_stbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: + inst_converted = _ffi.cast('const TInstant *', inst) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeoinst_restrict_stbox(inst_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_restrict_geom( - seq: Annotated[_ffi.CData, "const TSequence *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], - atfunc: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tgeoseq_restrict_geom(seq: Annotated[_ffi.CData, 'const TSequence *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + seq_converted = _ffi.cast('const TSequence *', seq) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tgeoseq_restrict_geom(seq_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_restrict_stbox( - seq: Annotated[_ffi.CData, "const TSequence *"], - box: Annotated[_ffi.CData, "const STBox *"], - border_inc: bool, - atfunc: bool, -) -> Annotated[_ffi.CData, "Temporal *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("const STBox *", box) +def tgeoseq_restrict_stbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeoseq_restrict_stbox(seq_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_restrict_geom( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], - gs: Annotated[_ffi.CData, "const GSERIALIZED *"], - zspan: Annotated[_ffi.CData, "const Span *"], - atfunc: bool, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) +def tgeoseqset_restrict_geom(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) result = _lib.tgeoseqset_restrict_geom(ss_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_restrict_stbox( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], - box: Annotated[_ffi.CData, "const STBox *"], - border_inc: bool, - atfunc: bool, -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("const STBox *", box) +def tgeoseqset_restrict_stbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tgeoseqset_restrict_stbox(ss_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def spatial_srid( - d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] -) -> Annotated[_ffi.CData, "int32_t"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def spatial_srid(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'int32_t']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.spatial_srid(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_set_srid( - d: Annotated[_ffi.CData, "Datum"], - basetype: Annotated[_ffi.CData, "meosType"], - srid: Annotated[_ffi.CData, "int32_t"], -) -> Annotated[bool, "bool"]: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - srid_converted = _ffi.cast("int32_t", srid) +def spatial_set_srid(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[bool, 'bool']: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + srid_converted = _ffi.cast('int32_t', srid) result = _lib.spatial_set_srid(d_converted, basetype_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatialinst_srid(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[int, "int"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tspatialinst_srid(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, 'int']: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tspatialinst_srid(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_azimuth(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_azimuth(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"], prevlength: float -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_cumulative_length(seq: Annotated[_ffi.CData, 'const TSequence *'], prevlength: float) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[bool, "bool"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_is_simple(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_length(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, '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_linear_trajectory( - seq: Annotated[_ffi.CData, "const TSequence *"], unary_union: bool -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_linear_trajectory(seq: Annotated[_ffi.CData, 'const TSequence *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_linear_trajectory(seq_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_stboxes( - seq: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeoseq_stboxes(seq_converted, count_converted) +def tgeoseq_stboxes(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') + result = _lib.tgeoseq_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 tgeoseq_split_n_stboxes( - seq: Annotated[_ffi.CData, "const TSequence *"], max_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeoseq_split_n_stboxes(seq_converted, max_count, count_converted) +def tgeoseq_split_n_stboxes(seq: Annotated[_ffi.CData, 'const TSequence *'], max_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') + result = _lib.tgeoseq_split_n_stboxes(seq_converted, max_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tpointseqset_azimuth(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_azimuth(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_cumulative_length(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[bool, "bool"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_is_simple(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[bool, '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: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_length(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, '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 tgeoseqset_stboxes( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeoseqset_stboxes(ss_converted, count_converted) +def tgeoseqset_stboxes(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') + result = _lib.tgeoseqset_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 tgeoseqset_split_n_stboxes( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], max_count: int, count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "STBox *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tgeoseqset_split_n_stboxes(ss_converted, max_count, count_converted) +def tgeoseqset_split_n_stboxes(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], max_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') + result = _lib.tgeoseqset_split_n_stboxes(ss_converted, max_count, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tpoint_get_coord( - temp: Annotated[_ffi.CData, "const Temporal *"], coord: int -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_coord(temp: Annotated[_ffi.CData, 'const Temporal *'], coord: int) -> Annotated[_ffi.CData, '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 tgeominst_tgeoginst( - inst: Annotated[_ffi.CData, "const TInstant *"], oper: bool -) -> Annotated[_ffi.CData, "TInstant *"]: - inst_converted = _ffi.cast("const TInstant *", inst) +def tgeominst_tgeoginst(inst: Annotated[_ffi.CData, 'const TInstant *'], oper: bool) -> Annotated[_ffi.CData, 'TInstant *']: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tgeominst_tgeoginst(inst_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeomseq_tgeogseq( - seq: Annotated[_ffi.CData, "const TSequence *"], oper: bool -) -> Annotated[_ffi.CData, "TSequence *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tgeomseq_tgeogseq(seq: Annotated[_ffi.CData, 'const TSequence *'], oper: bool) -> Annotated[_ffi.CData, 'TSequence *']: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tgeomseq_tgeogseq(seq_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeomseqset_tgeogseqset( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], oper: bool -) -> Annotated[_ffi.CData, "TSequenceSet *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tgeomseqset_tgeogseqset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], oper: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tgeomseqset_tgeogseqset(ss_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeom_tgeog(temp: Annotated[_ffi.CData, "const Temporal *"], oper: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeom_tgeog(temp: Annotated[_ffi.CData, 'const Temporal *'], oper: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeom_tgeog(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeo_tpoint(temp: Annotated[_ffi.CData, "const Temporal *"], oper: bool) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeo_tpoint(temp: Annotated[_ffi.CData, 'const Temporal *'], oper: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeo_tpoint(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tspatialinst_set_srid( - inst: Annotated[_ffi.CData, "TInstant *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[None, "void"]: - inst_converted = _ffi.cast("TInstant *", inst) - srid_converted = _ffi.cast("int32_t", srid) +def tspatialinst_set_srid(inst: Annotated[_ffi.CData, 'TInstant *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: + inst_converted = _ffi.cast('TInstant *', inst) + srid_converted = _ffi.cast('int32_t', srid) _lib.tspatialinst_set_srid(inst_converted, srid_converted) _check_error() -def tpointseq_make_simple( - seq: Annotated[_ffi.CData, "const TSequence *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - seq_converted = _ffi.cast("const TSequence *", seq) - count_converted = _ffi.cast("int *", count) - result = _lib.tpointseq_make_simple(seq_converted, count_converted) +def tpointseq_make_simple(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 tspatialseq_set_srid( - seq: Annotated[_ffi.CData, "TSequence *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[None, "void"]: - seq_converted = _ffi.cast("TSequence *", seq) - srid_converted = _ffi.cast("int32_t", srid) +def tspatialseq_set_srid(seq: Annotated[_ffi.CData, 'TSequence *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: + seq_converted = _ffi.cast('TSequence *', seq) + srid_converted = _ffi.cast('int32_t', srid) _lib.tspatialseq_set_srid(seq_converted, srid_converted) _check_error() -def tpointseqset_make_simple( - ss: Annotated[_ffi.CData, "const TSequenceSet *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "TSequence **"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count_converted = _ffi.cast("int *", count) - result = _lib.tpointseqset_make_simple(ss_converted, count_converted) +def tpointseqset_make_simple(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, '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 tspatialseqset_set_srid( - ss: Annotated[_ffi.CData, "TSequenceSet *"], srid: Annotated[_ffi.CData, "int32_t"] -) -> Annotated[None, "void"]: - ss_converted = _ffi.cast("TSequenceSet *", ss) - srid_converted = _ffi.cast("int32_t", srid) +def tspatialseqset_set_srid(ss: Annotated[_ffi.CData, 'TSequenceSet *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: + ss_converted = _ffi.cast('TSequenceSet *', ss) + srid_converted = _ffi.cast('int32_t', srid) _lib.tspatialseqset_set_srid(ss_converted, srid_converted) _check_error() -def tpointseq_twcentroid(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_twcentroid(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TSequenceSet *"], -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_twcentroid(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, '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 npoint_as_ewkt(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_as_ewkt(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_as_ewkt(np_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 npoint_as_hexwkb( - np: Annotated[_ffi.CData, "const Npoint *"], variant: int -) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "size_t *"]]: - np_converted = _ffi.cast("const Npoint *", np) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def npoint_as_hexwkb(np: Annotated[_ffi.CData, 'const Npoint *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, 'size_t *']]: + np_converted = _ffi.cast('const Npoint *', np) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.npoint_as_hexwkb(np_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 npoint_as_text(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_as_text(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_as_text(np_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 npoint_as_wkb( - np: Annotated[_ffi.CData, "const Npoint *"], variant: int -) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: - np_converted = _ffi.cast("const Npoint *", np) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def npoint_as_wkb(np: Annotated[_ffi.CData, 'const Npoint *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: + np_converted = _ffi.cast('const Npoint *', np) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.npoint_as_wkb(np_converted, variant_converted, size_out) _check_error() return result if result != _ffi.NULL else None, size_out[0] -def npoint_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "Npoint *"]: - hexwkb_converted = hexwkb.encode("utf-8") +def npoint_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'Npoint *']: + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.npoint_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_from_wkb( - wkb: Annotated[_ffi.CData, "const uint8_t *"], size: Annotated[_ffi.CData, "size_t"] -) -> Annotated[_ffi.CData, "Npoint *"]: - wkb_converted = _ffi.cast("const uint8_t *", wkb) - size_converted = _ffi.cast("size_t", size) +def npoint_from_wkb(wkb: Annotated[_ffi.CData, 'const uint8_t *'], size: Annotated[_ffi.CData, 'size_t']) -> Annotated[_ffi.CData, 'Npoint *']: + wkb_converted = _ffi.cast('const uint8_t *', wkb) + size_converted = _ffi.cast('size_t', size) result = _lib.npoint_from_wkb(wkb_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_in(string: str) -> Annotated[_ffi.CData, "Npoint *"]: - string_converted = string.encode("utf-8") +def npoint_in(string: str) -> Annotated[_ffi.CData, 'Npoint *']: + string_converted = string.encode('utf-8') result = _lib.npoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_out(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_out(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_out(np_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 nsegment_in(string: str) -> Annotated[_ffi.CData, "Nsegment *"]: - string_converted = string.encode("utf-8") +def nsegment_in(string: str) -> Annotated[_ffi.CData, 'Nsegment *']: + string_converted = string.encode('utf-8') result = _lib.nsegment_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_out(ns: Annotated[_ffi.CData, "const Nsegment *"], maxdd: int) -> Annotated[str, "char *"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_out(ns: Annotated[_ffi.CData, 'const Nsegment *'], maxdd: int) -> Annotated[str, 'char *']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_out(ns_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 npoint_make(rid: int, pos: float) -> Annotated[_ffi.CData, "Npoint *"]: - rid_converted = _ffi.cast("int64", rid) +def npoint_make(rid: int, pos: float) -> Annotated[_ffi.CData, 'Npoint *']: + rid_converted = _ffi.cast('int64', rid) result = _lib.npoint_make(rid_converted, pos) _check_error() return result if result != _ffi.NULL else None -def nsegment_make(rid: int, pos1: float, pos2: float) -> Annotated[_ffi.CData, "Nsegment *"]: - rid_converted = _ffi.cast("int64", rid) +def nsegment_make(rid: int, pos1: float, pos2: float) -> Annotated[_ffi.CData, 'Nsegment *']: + rid_converted = _ffi.cast('int64', rid) result = _lib.nsegment_make(rid_converted, pos1, pos2) _check_error() return result if result != _ffi.NULL else None -def geompoint_to_npoint(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Npoint *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geompoint_to_npoint(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Npoint *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geompoint_to_npoint(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_to_nsegment(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Nsegment *"]: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geom_to_nsegment(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Nsegment *']: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geom_to_nsegment(gs_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_geompoint(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_to_geompoint(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_to_geompoint(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_nsegment(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "Nsegment *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_to_nsegment(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Nsegment *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_to_nsegment(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_stbox(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "STBox *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'STBox *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_to_stbox(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_to_geom(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_to_geom(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_to_geom(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_to_stbox(np: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "STBox *"]: - np_converted = _ffi.cast("const Nsegment *", np) +def nsegment_to_stbox(np: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'STBox *']: + np_converted = _ffi.cast('const Nsegment *', np) result = _lib.nsegment_to_stbox(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_hash(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[int, "uint32"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_hash(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'uint32']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_hash(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_hash_extended(np: Annotated[_ffi.CData, "const Npoint *"], seed: int) -> Annotated[int, "uint64"]: - np_converted = _ffi.cast("const Npoint *", np) - seed_converted = _ffi.cast("uint64", seed) +def npoint_hash_extended(np: Annotated[_ffi.CData, 'const Npoint *'], seed: int) -> Annotated[int, 'uint64']: + np_converted = _ffi.cast('const Npoint *', np) + seed_converted = _ffi.cast('uint64', seed) result = _lib.npoint_hash_extended(np_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_position(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[float, "double"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_position(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[float, 'double']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_position(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_route(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[int, "int64"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_route(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int64']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_route(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_end_position(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[float, "double"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_end_position(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[float, 'double']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_end_position(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_route(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[int, "int64"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_route(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[int, 'int64']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_route(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_start_position(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[float, "double"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_start_position(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[float, 'double']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_start_position(ns_converted) _check_error() return result if result != _ffi.NULL else None -def route_exists(rid: int) -> Annotated[bool, "bool"]: - rid_converted = _ffi.cast("int64", rid) +def route_exists(rid: int) -> Annotated[bool, 'bool']: + rid_converted = _ffi.cast('int64', rid) result = _lib.route_exists(rid_converted) _check_error() return result if result != _ffi.NULL else None -def route_geom(rid: int) -> Annotated[_ffi.CData, "const GSERIALIZED *"]: - rid_converted = _ffi.cast("int64", rid) +def route_geom(rid: int) -> Annotated[_ffi.CData, 'const GSERIALIZED *']: + rid_converted = _ffi.cast('int64', rid) result = _lib.route_geom(rid_converted) _check_error() return result if result != _ffi.NULL else None -def route_length(rid: int) -> Annotated[float, "double"]: - rid_converted = _ffi.cast("int64", rid) +def route_length(rid: int) -> Annotated[float, 'double']: + rid_converted = _ffi.cast('int64', rid) result = _lib.route_length(rid_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_round(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[_ffi.CData, "Npoint *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_round(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[_ffi.CData, 'Npoint *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_round(np_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def nsegment_round(ns: Annotated[_ffi.CData, "const Nsegment *"], maxdd: int) -> Annotated[_ffi.CData, "Nsegment *"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_round(ns: Annotated[_ffi.CData, 'const Nsegment *'], maxdd: int) -> Annotated[_ffi.CData, 'Nsegment *']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_round(ns_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def get_srid_ways() -> Annotated[_ffi.CData, "int32_t"]: +def get_srid_ways() -> Annotated[_ffi.CData, 'int32_t']: result = _lib.get_srid_ways() _check_error() return result if result != _ffi.NULL else None -def npoint_srid(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "int32_t"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_srid(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'int32_t']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_srid(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_srid(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "int32_t"]: - ns_converted = _ffi.cast("const Nsegment *", ns) +def nsegment_srid(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'int32_t']: + ns_converted = _ffi.cast('const Nsegment *', ns) result = _lib.nsegment_srid(ns_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_timestamptz_to_stbox( - np: Annotated[_ffi.CData, "const Npoint *"], t: int -) -> Annotated[_ffi.CData, "STBox *"]: - np_converted = _ffi.cast("const Npoint *", np) - t_converted = _ffi.cast("TimestampTz", t) +def npoint_timestamptz_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *'], t: int) -> Annotated[_ffi.CData, 'STBox *']: + np_converted = _ffi.cast('const Npoint *', np) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.npoint_timestamptz_to_stbox(np_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_tstzspan_to_stbox( - np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Span *"] -) -> Annotated[_ffi.CData, "STBox *"]: - np_converted = _ffi.cast("const Npoint *", np) - s_converted = _ffi.cast("const Span *", s) +def npoint_tstzspan_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'STBox *']: + np_converted = _ffi.cast('const Npoint *', np) + s_converted = _ffi.cast('const Span *', s) result = _lib.npoint_tstzspan_to_stbox(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_cmp( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[int, "int"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_cmp(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_cmp(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_eq( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_eq(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_eq(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_ge( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_ge(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_ge(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_gt( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_gt(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_gt(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_le( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_le(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_le(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_lt( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_lt(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_lt(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_ne( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_ne(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_ne(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_same( - np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - np1_converted = _ffi.cast("const Npoint *", np1) - np2_converted = _ffi.cast("const Npoint *", np2) +def npoint_same(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + np1_converted = _ffi.cast('const Npoint *', np1) + np2_converted = _ffi.cast('const Npoint *', np2) result = _lib.npoint_same(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_cmp( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[int, "int"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_cmp(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[int, 'int']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_cmp(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_eq( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_eq(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_eq(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_ge( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_ge(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_ge(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_gt( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_gt(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_gt(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_le( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_le(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_le(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_lt( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_lt(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_lt(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_ne( - ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] -) -> Annotated[bool, "bool"]: - ns1_converted = _ffi.cast("const Nsegment *", ns1) - ns2_converted = _ffi.cast("const Nsegment *", ns2) +def nsegment_ne(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: + ns1_converted = _ffi.cast('const Nsegment *', ns1) + ns2_converted = _ffi.cast('const Nsegment *', ns2) result = _lib.nsegment_ne(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: - string_converted = string.encode("utf-8") +def npointset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: + string_converted = string.encode('utf-8') result = _lib.npointset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_out(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: - s_converted = _ffi.cast("const Set *", s) +def npointset_out(s: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.npointset_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 npointset_make(values: Annotated[list, "Npoint **"], count: int) -> Annotated[_ffi.CData, "Set *"]: - values_converted = [_ffi.cast("Npoint *", x) for x in values] +def npointset_make(values: Annotated[list, 'Npoint **'], count: int) -> Annotated[_ffi.CData, 'Set *']: + values_converted = [_ffi.cast('Npoint *', x) for x in values] result = _lib.npointset_make(values_converted, count) _check_error() return result if result != _ffi.NULL else None -def npoint_to_set(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "Set *"]: - np_converted = _ffi.cast("const Npoint *", np) +def npoint_to_set(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_to_set(np_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint *"]: - s_converted = _ffi.cast("const Set *", s) +def npointset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.npointset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_routes(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) +def npointset_routes(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.npointset_routes(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint *"]: - s_converted = _ffi.cast("const Set *", s) +def npointset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint *']: + s_converted = _ffi.cast('const Set *', s) result = _lib.npointset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "Npoint **"]: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("Npoint **") +def npointset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, 'Npoint **']: + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('Npoint **') result = _lib.npointset_value_n(s_converted, n, out_result) _check_error() if result: @@ -20654,554 +17888,464 @@ def npointset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annota return None -def npointset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint **"]: - s_converted = _ffi.cast("const Set *", s) +def npointset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint **']: + s_converted = _ffi.cast('const Set *', s) result = _lib.npointset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_npoint_set( - np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[bool, "bool"]: - np_converted = _ffi.cast("const Npoint *", np) - s_converted = _ffi.cast("const Set *", s) +def contained_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: + np_converted = _ffi.cast('const Npoint *', np) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_npoint( - s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[bool, "bool"]: - s_converted = _ffi.cast("const Set *", s) - np_converted = _ffi.cast("const Npoint *", np) +def contains_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: + s_converted = _ffi.cast('const Set *', s) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.contains_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_npoint_set( - np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - np_converted = _ffi.cast("const Npoint *", np) - s_converted = _ffi.cast("const Set *", s) +def intersection_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + np_converted = _ffi.cast('const Npoint *', np) + s_converted = _ffi.cast('const Set *', s) result = _lib.intersection_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_npoint( - s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - np_converted = _ffi.cast("const Npoint *", np) +def intersection_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.intersection_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def minus_npoint_set( - np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - np_converted = _ffi.cast("const Npoint *", np) - s_converted = _ffi.cast("const Set *", s) +def minus_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + np_converted = _ffi.cast('const Npoint *', np) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_npoint( - s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - np_converted = _ffi.cast("const Npoint *", np) +def minus_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.minus_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_union_transfn( - state: Annotated[_ffi.CData, "Set *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Set *"]: - state_converted = _ffi.cast("Set *", state) - np_converted = _ffi.cast("const Npoint *", np) +def npoint_union_transfn(state: Annotated[_ffi.CData, 'Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: + state_converted = _ffi.cast('Set *', state) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.npoint_union_transfn(state_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def union_npoint_set( - np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Set *"]: - np_converted = _ffi.cast("const Npoint *", np) - s_converted = _ffi.cast("const Set *", s) +def union_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: + np_converted = _ffi.cast('const Npoint *', np) + s_converted = _ffi.cast('const Set *', s) result = _lib.union_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_npoint( - s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Set *"]: - s_converted = _ffi.cast("const Set *", s) - np_converted = _ffi.cast("const Npoint *", np) +def union_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: + s_converted = _ffi.cast('const Set *', s) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.union_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: - string_converted = string.encode("utf-8") +def tnpoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: + string_converted = string.encode('utf-8') result = _lib.tnpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_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 tnpointinst_make(np: Annotated[_ffi.CData, "const Npoint *"], t: int) -> Annotated[_ffi.CData, "TInstant *"]: - np_converted = _ffi.cast("const Npoint *", np) - t_converted = _ffi.cast("TimestampTz", t) +def tnpointinst_make(np: Annotated[_ffi.CData, 'const Npoint *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: + np_converted = _ffi.cast('const Npoint *', np) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tnpointinst_make(np_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tnpoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeompoint_to_tnpoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeompoint_to_tnpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_to_tgeompoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_to_tgeompoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_cumulative_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_cumulative_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_cumulative_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_positions( - temp: Annotated[_ffi.CData, "const Temporal *"], count: Annotated[_ffi.CData, "int *"] -) -> Annotated[_ffi.CData, "Nsegment **"]: - temp_converted = _ffi.cast("const Temporal *", temp) - count_converted = _ffi.cast("int *", count) - result = _lib.tnpoint_positions(temp_converted, count_converted) +def tnpoint_positions(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Nsegment **'], Annotated[_ffi.CData, 'int']]: + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') + result = _lib.tnpoint_positions(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnpoint_route(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int64"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_route(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int64']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_route(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_routes(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Set *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_routes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Set *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_routes(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_speed(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_speed(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_speed(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_trajectory(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_trajectory(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_trajectory(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_twcentroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) +def tnpoint_twcentroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnpoint_twcentroid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tnpoint_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tnpoint_at_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def tnpoint_at_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.tnpoint_at_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_npointset( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def tnpoint_at_npointset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.tnpoint_at_npointset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tnpoint_at_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tnpoint_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_geom( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tnpoint_minus_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tnpoint_minus_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def tnpoint_minus_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.tnpoint_minus_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_npointset( - temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def tnpoint_minus_npointset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.tnpoint_minus_npointset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tnpoint_minus_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tnpoint_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def tdistance_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.tdistance_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_point( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tdistance_tnpoint_point(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tdistance_tnpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tdistance_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tdistance_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nad_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nad_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def nad_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.nad_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_stbox( - temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] -) -> Annotated[float, "double"]: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def nad_tnpoint_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.nad_tnpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[float, "double"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nad_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nai_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nai_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def nai_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'TInstant *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.nai_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "TInstant *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nai_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nai_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_geo( - temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def shortestline_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.shortestline_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def shortestline_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.shortestline_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[_ffi.CData, "GSERIALIZED *"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def shortestline_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.shortestline_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_tcentroid_transfn( - state: Annotated[_ffi.CData, "SkipList *"], temp: Annotated[_ffi.CData, "Temporal *"] -) -> Annotated[_ffi.CData, "SkipList *"]: - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("Temporal *", temp) +def tnpoint_tcentroid_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'Temporal *']) -> Annotated[_ffi.CData, 'SkipList *']: + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('Temporal *', temp) result = _lib.tnpoint_tcentroid_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_npoint_tnpoint( - np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - np_converted = _ffi.cast("const Npoint *", np) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_eq_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + np_converted = _ffi.cast('const Npoint *', np) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.always_eq_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def always_eq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.always_eq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_eq_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.always_eq_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_npoint_tnpoint( - np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - np_converted = _ffi.cast("const Npoint *", np) - temp_converted = _ffi.cast("const Temporal *", temp) +def always_ne_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + np_converted = _ffi.cast('const Npoint *', np) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.always_ne_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def always_ne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.always_ne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def always_ne_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.always_ne_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_npoint_tnpoint( - np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - np_converted = _ffi.cast("const Npoint *", np) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_eq_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + np_converted = _ffi.cast('const Npoint *', np) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ever_eq_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def ever_eq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.ever_eq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_eq_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ever_eq_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_npoint_tnpoint( - np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - np_converted = _ffi.cast("const Npoint *", np) - temp_converted = _ffi.cast("const Temporal *", temp) +def ever_ne_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + np_converted = _ffi.cast('const Npoint *', np) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ever_ne_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[int, "int"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def ever_ne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.ever_ne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tnpoint_tnpoint( - temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] -) -> Annotated[int, "int"]: - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def ever_ne_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.ever_ne_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def teq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.teq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tnpoint_npoint( - temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] -) -> Annotated[_ffi.CData, "Temporal *"]: - temp_converted = _ffi.cast("const Temporal *", temp) - np_converted = _ffi.cast("const Npoint *", np) +def tne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: + temp_converted = _ffi.cast('const Temporal *', temp) + np_converted = _ffi.cast('const Npoint *', np) result = _lib.tne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None + + From 0f47ba98c75df69615301105a2c1bfea6007a001 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 14 May 2026 17:20:51 +0200 Subject: [PATCH 10/11] Reformat regenerated functions.py with ruff The 1.3 codegen wraps long lines via formatter post-processing, not during emission. ruff format restores the canonical line lengths so the Lint workflow passes. --- pymeos_cffi/functions.py | 15381 ++++++++++++++++++++++--------------- 1 file changed, 9107 insertions(+), 6274 deletions(-) diff --git a/pymeos_cffi/functions.py b/pymeos_cffi/functions.py index 8557f4b..24f15ea 100644 --- a/pymeos_cffi/functions.py +++ b/pymeos_cffi/functions.py @@ -158,9 +158,7 @@ def tbox_shift_scale_float( hasshift: bool, haswidth: bool, ) -> Annotated[_ffi.CData, "TBox *"]: - return tbox_shift_scale_value( - box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth - ) + return tbox_shift_scale_value(box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth) def tbox_shift_scale_int( @@ -170,232 +168,236 @@ def tbox_shift_scale_int( hasshift: bool, haswidth: bool, ) -> Annotated[_ffi.CData, "TBox *"]: - return tbox_shift_scale_value( - box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth - ) + return tbox_shift_scale_value(box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth) # ----------------------------------------------------------------------------- # ----------------------End of manually-defined functions---------------------- # ----------------------------------------------------------------------------- -def date_in(string: str) -> Annotated[int, 'DateADT']: - string_converted = string.encode('utf-8') +def date_in(string: str) -> Annotated[int, "DateADT"]: + string_converted = string.encode("utf-8") result = _lib.date_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def date_out(d: int) -> Annotated[str, 'char *']: - d_converted = _ffi.cast('DateADT', d) +def date_out(d: int) -> Annotated[str, "char *"]: + d_converted = _ffi.cast("DateADT", d) result = _lib.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 interval_cmp(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'int']: - interv1_converted = _ffi.cast('const Interval *', interv1) - interv2_converted = _ffi.cast('const Interval *', interv2) +def interval_cmp( + interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[int, "int"]: + interv1_converted = _ffi.cast("const Interval *", interv1) + interv2_converted = _ffi.cast("const Interval *", interv2) result = _lib.interval_cmp(interv1_converted, interv2_converted) _check_error() return result if result != _ffi.NULL else None -def interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'Interval *']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, "Interval *"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.interval_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def interval_out(interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[str, 'char *']: - interv_converted = _ffi.cast('const Interval *', interv) +def interval_out(interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[str, "char *"]: + interv_converted = _ffi.cast("const Interval *", interv) result = _lib.interval_out(interv_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 time_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'TimeADT']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def time_in(string: str, typmod: int) -> Annotated[_ffi.CData, "TimeADT"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.time_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def time_out(t: Annotated[_ffi.CData, 'TimeADT']) -> Annotated[str, 'char *']: - t_converted = _ffi.cast('TimeADT', t) +def time_out(t: Annotated[_ffi.CData, "TimeADT"]) -> Annotated[str, "char *"]: + t_converted = _ffi.cast("TimeADT", t) result = _lib.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 timestamp_in(string: str, typmod: int) -> Annotated[int, 'Timestamp']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def timestamp_in(string: str, typmod: int) -> Annotated[int, "Timestamp"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.timestamp_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def timestamp_out(t: int) -> Annotated[str, 'char *']: - t_converted = _ffi.cast('Timestamp', t) +def timestamp_out(t: int) -> Annotated[str, "char *"]: + t_converted = _ffi.cast("Timestamp", t) result = _lib.timestamp_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 timestamptz_in(string: str, typmod: int) -> Annotated[int, 'TimestampTz']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def timestamptz_in(string: str, typmod: int) -> Annotated[int, "TimestampTz"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.timestamptz_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_out(t: int) -> Annotated[str, 'char *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_out(t: int) -> Annotated[str, "char *"]: + t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_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 rtree_create_intspan() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_intspan() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_intspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_bigintspan() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_bigintspan() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_bigintspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_floatspan() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_floatspan() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_floatspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_datespan() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_datespan() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_datespan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_tstzspan() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_tstzspan() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_tstzspan() _check_error() return result if result != _ffi.NULL else None -def rtree_create_tbox() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_tbox() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_tbox() _check_error() return result if result != _ffi.NULL else None -def rtree_create_stbox() -> Annotated[_ffi.CData, 'RTree *']: +def rtree_create_stbox() -> Annotated[_ffi.CData, "RTree *"]: result = _lib.rtree_create_stbox() _check_error() return result if result != _ffi.NULL else None -def rtree_free(rtree: Annotated[_ffi.CData, 'RTree *']) -> Annotated[None, 'void']: - rtree_converted = _ffi.cast('RTree *', rtree) +def rtree_free(rtree: Annotated[_ffi.CData, "RTree *"]) -> Annotated[None, "void"]: + rtree_converted = _ffi.cast("RTree *", rtree) _lib.rtree_free(rtree_converted) _check_error() -def rtree_insert(rtree: Annotated[_ffi.CData, 'RTree *'], box: Annotated[_ffi.CData, 'void *'], id: int) -> Annotated[None, 'void']: - rtree_converted = _ffi.cast('RTree *', rtree) - box_converted = _ffi.cast('void *', box) - id_converted = _ffi.cast('int64', id) +def rtree_insert( + rtree: Annotated[_ffi.CData, "RTree *"], box: Annotated[_ffi.CData, "void *"], id: int +) -> Annotated[None, "void"]: + rtree_converted = _ffi.cast("RTree *", rtree) + box_converted = _ffi.cast("void *", box) + id_converted = _ffi.cast("int64", id) _lib.rtree_insert(rtree_converted, box_converted, id_converted) _check_error() -def rtree_search(rtree: Annotated[_ffi.CData, 'const RTree *'], query: Annotated[_ffi.CData, 'const void *']) -> tuple[Annotated[_ffi.CData, 'int *'], Annotated[_ffi.CData, 'int']]: - rtree_converted = _ffi.cast('const RTree *', rtree) - query_converted = _ffi.cast('const void *', query) - count = _ffi.new('int *') +def rtree_search( + rtree: Annotated[_ffi.CData, "const RTree *"], query: Annotated[_ffi.CData, "const void *"] +) -> tuple[Annotated[_ffi.CData, "int *"], Annotated[_ffi.CData, "int"]]: + rtree_converted = _ffi.cast("const RTree *", rtree) + query_converted = _ffi.cast("const void *", query) + count = _ffi.new("int *") result = _lib.rtree_search(rtree_converted, query_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def meos_errno() -> Annotated[int, 'int']: +def meos_errno() -> Annotated[int, "int"]: result = _lib.meos_errno() _check_error() return result if result != _ffi.NULL else None -def meos_errno_set(err: int) -> Annotated[int, 'int']: +def meos_errno_set(err: int) -> Annotated[int, "int"]: result = _lib.meos_errno_set(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_restore(err: int) -> Annotated[int, 'int']: +def meos_errno_restore(err: int) -> Annotated[int, "int"]: result = _lib.meos_errno_restore(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_reset() -> Annotated[int, 'int']: +def meos_errno_reset() -> Annotated[int, "int"]: result = _lib.meos_errno_reset() _check_error() return result if result != _ffi.NULL else None -def meos_finalize_projsrs() -> Annotated[None, 'void']: +def meos_finalize_projsrs() -> Annotated[None, "void"]: _lib.meos_finalize_projsrs() _check_error() -def meos_finalize_ways() -> Annotated[None, 'void']: +def meos_finalize_ways() -> Annotated[None, "void"]: _lib.meos_finalize_ways() _check_error() -def meos_set_datestyle(newval: str, extra: Annotated[_ffi.CData, 'void *']) -> Annotated[bool, 'bool']: - newval_converted = newval.encode('utf-8') - extra_converted = _ffi.cast('void *', extra) +def meos_set_datestyle(newval: str, extra: Annotated[_ffi.CData, "void *"]) -> Annotated[bool, "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: int | None) -> Annotated[bool, 'bool']: - newval_converted = newval.encode('utf-8') +def meos_set_intervalstyle(newval: str, extra: int | None) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def meos_get_datestyle() -> Annotated[str, 'char *']: +def meos_get_datestyle() -> Annotated[str, "char *"]: 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() -> Annotated[str, 'char *']: +def meos_get_intervalstyle() -> Annotated[str, "char *"]: 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_set_spatial_ref_sys_csv(path: Annotated[_ffi.CData, 'const char*']) -> Annotated[None, 'void']: - path_converted = _ffi.cast('const char*', path) +def meos_set_spatial_ref_sys_csv(path: Annotated[_ffi.CData, "const char*"]) -> Annotated[None, "void"]: + path_converted = _ffi.cast("const char*", path) _lib.meos_set_spatial_ref_sys_csv(path_converted) _check_error() @@ -411,257 +413,269 @@ def meos_initialize(tz_str: str | None) -> None: _lib.meos_initialize() # Check if local spatial ref system csv exists (meaning wheel installation). If it does, use it. - wheel_path = os.path.join( - os.path.dirname(__file__), "meos_data", "spatial_ref_sys.csv" - ) + wheel_path = os.path.join(os.path.dirname(__file__), "meos_data", "spatial_ref_sys.csv") if os.path.exists(wheel_path): _lib.meos_set_spatial_ref_sys_csv(wheel_path.encode("utf-8")) # Timezone is already initialized by meos_initialize, so we only need to set it if tz_str is provided if tz_str is not None: - _lib.meos_initialize_timezone(tz_str.encode('utf-8')) + _lib.meos_initialize_timezone(tz_str.encode("utf-8")) _lib.meos_initialize_error_handler(_lib.py_error_handler) -def meos_finalize() -> Annotated[None, 'void']: +def meos_finalize() -> Annotated[None, "void"]: _lib.meos_finalize() _check_error() -def add_date_int(d: int, days: int) -> Annotated[int, 'DateADT']: - d_converted = _ffi.cast('DateADT', d) - days_converted = _ffi.cast('int32', days) +def add_date_int(d: int, days: int) -> Annotated[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 add_interval_interval(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Interval *']: - interv1_converted = _ffi.cast('const Interval *', interv1) - interv2_converted = _ffi.cast('const Interval *', interv2) +def add_interval_interval( + interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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 add_timestamptz_interval(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'TimestampTz']: - t_converted = _ffi.cast('TimestampTz', t) - interv_converted = _ffi.cast('const Interval *', interv) +def add_timestamptz_interval( + t: int, interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[int, "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() return result if result != _ffi.NULL else None -def bool_in(string: str) -> Annotated[bool, 'bool']: - string_converted = string.encode('utf-8') +def bool_in(string: str) -> Annotated[bool, "bool"]: + string_converted = string.encode("utf-8") result = _lib.bool_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bool_out(b: bool) -> Annotated[str, 'char *']: +def bool_out(b: bool) -> Annotated[str, "char *"]: 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 date_to_timestamp(dateVal: int) -> Annotated[int, 'Timestamp']: - dateVal_converted = _ffi.cast('DateADT', dateVal) +def date_to_timestamp(dateVal: int) -> Annotated[int, "Timestamp"]: + dateVal_converted = _ffi.cast("DateADT", dateVal) result = _lib.date_to_timestamp(dateVal_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_timestamptz(d: int) -> Annotated[int, 'TimestampTz']: - d_converted = _ffi.cast('DateADT', d) +def date_to_timestamptz(d: int) -> Annotated[int, "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 float_exp(d: float) -> Annotated[float, 'double']: +def float_exp(d: float) -> Annotated[float, "double"]: result = _lib.float_exp(d) _check_error() return result if result != _ffi.NULL else None -def float_ln(d: float) -> Annotated[float, 'double']: +def float_ln(d: float) -> Annotated[float, "double"]: result = _lib.float_ln(d) _check_error() return result if result != _ffi.NULL else None -def float_log10(d: float) -> Annotated[float, 'double']: +def float_log10(d: float) -> Annotated[float, "double"]: result = _lib.float_log10(d) _check_error() return result if result != _ffi.NULL else None -def float8_out(d: float, maxdd: int) -> Annotated[str, 'char *']: +def float8_out(d: float, maxdd: int) -> Annotated[str, "char *"]: result = _lib.float8_out(d, 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_round(d: float, maxdd: int) -> Annotated[float, 'double']: +def float_round(d: float, maxdd: int) -> Annotated[float, "double"]: result = _lib.float_round(d, maxdd) _check_error() return result if result != _ffi.NULL else None -def int32_cmp(l: int, r: int) -> Annotated[int, 'int']: - l_converted = _ffi.cast('int32', l) - r_converted = _ffi.cast('int32', r) +def int32_cmp(l: int, r: int) -> Annotated[int, "int"]: + l_converted = _ffi.cast("int32", l) + r_converted = _ffi.cast("int32", r) result = _lib.int32_cmp(l_converted, r_converted) _check_error() return result if result != _ffi.NULL else None -def int64_cmp(l: int, r: int) -> Annotated[int, 'int']: - l_converted = _ffi.cast('int64', l) - r_converted = _ffi.cast('int64', r) +def int64_cmp(l: int, r: int) -> Annotated[int, "int"]: + l_converted = _ffi.cast("int64", l) + r_converted = _ffi.cast("int64", r) result = _lib.int64_cmp(l_converted, r_converted) _check_error() return result if result != _ffi.NULL else None -def interval_make(years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float) -> Annotated[_ffi.CData, '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.interval_make(years_converted, months_converted, weeks_converted, days_converted, hours_converted, mins_converted, secs) +def interval_make( + years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float +) -> Annotated[_ffi.CData, "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.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 minus_date_date(d1: int, d2: int) -> Annotated[int, 'int']: - d1_converted = _ffi.cast('DateADT', d1) - d2_converted = _ffi.cast('DateADT', d2) +def minus_date_date(d1: int, d2: int) -> Annotated[int, "int"]: + 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 minus_date_int(d: int, days: int) -> Annotated[int, 'DateADT']: - d_converted = _ffi.cast('DateADT', d) - days_converted = _ffi.cast('int32', days) +def minus_date_int(d: int, days: int) -> Annotated[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 minus_timestamptz_interval(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'TimestampTz']: - t_converted = _ffi.cast('TimestampTz', t) - interv_converted = _ffi.cast('const Interval *', interv) +def minus_timestamptz_interval( + t: int, interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[int, "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 minus_timestamptz_timestamptz(t1: int, t2: int) -> Annotated[_ffi.CData, 'Interval *']: - t1_converted = _ffi.cast('TimestampTz', t1) - t2_converted = _ffi.cast('TimestampTz', t2) +def minus_timestamptz_timestamptz(t1: int, t2: int) -> Annotated[_ffi.CData, "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 mul_interval_double(interv: Annotated[_ffi.CData, 'const Interval *'], factor: float) -> Annotated[_ffi.CData, 'Interval *']: - interv_converted = _ffi.cast('const Interval *', interv) +def mul_interval_double( + interv: Annotated[_ffi.CData, "const Interval *"], factor: float +) -> Annotated[_ffi.CData, "Interval *"]: + interv_converted = _ffi.cast("const Interval *", interv) result = _lib.mul_interval_double(interv_converted, factor) _check_error() return result if result != _ffi.NULL else None -def pg_date_in(string: str) -> Annotated[int, 'DateADT']: - string_converted = string.encode('utf-8') +def pg_date_in(string: str) -> Annotated[int, "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: int) -> Annotated[str, 'char *']: - d_converted = _ffi.cast('DateADT', d) +def pg_date_out(d: int) -> Annotated[str, "char *"]: + 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_interval_cmp(interv1: Annotated[_ffi.CData, 'const Interval *'], interv2: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'int']: - interv1_converted = _ffi.cast('const Interval *', interv1) - interv2_converted = _ffi.cast('const Interval *', interv2) +def pg_interval_cmp( + interv1: Annotated[_ffi.CData, "const Interval *"], interv2: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[int, "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_interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'Interval *']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def pg_interval_in(string: str, typmod: int) -> Annotated[_ffi.CData, "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_out(interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[str, 'char *']: - interv_converted = _ffi.cast('const Interval *', interv) +def pg_interval_out(interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[str, "char *"]: + interv_converted = _ffi.cast("const Interval *", interv) result = _lib.pg_interval_out(interv_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) -> Annotated[int, 'Timestamp']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def pg_timestamp_in(string: str, typmod: int) -> Annotated[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_out(t: int) -> Annotated[str, 'char *']: - t_converted = _ffi.cast('Timestamp', t) +def pg_timestamp_out(t: int) -> Annotated[str, "char *"]: + t_converted = _ffi.cast("Timestamp", t) result = _lib.pg_timestamp_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_timestamptz_in(string: str, typmod: int) -> Annotated[int, 'TimestampTz']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def pg_timestamptz_in(string: str, typmod: int) -> Annotated[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_out(t: int) -> Annotated[str, 'char *']: - t_converted = _ffi.cast('TimestampTz', t) +def pg_timestamptz_out(t: int) -> Annotated[str, "char *"]: + t_converted = _ffi.cast("TimestampTz", t) result = _lib.pg_timestamptz_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 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 -def text_cmp(txt1: str, txt2: str) -> Annotated[int, 'int']: +def text_cmp(txt1: str, txt2: str) -> Annotated[int, "int"]: txt1_converted = cstring2text(txt1) txt2_converted = cstring2text(txt2) result = _lib.text_cmp(txt1_converted, txt2_converted) @@ -669,7 +683,7 @@ def text_cmp(txt1: str, txt2: str) -> Annotated[int, 'int']: return result if result != _ffi.NULL else None -def text_copy(txt: str) -> Annotated[str, 'text *']: +def text_copy(txt: str) -> Annotated[str, "text *"]: txt_converted = cstring2text(txt) result = _lib.text_copy(txt_converted) _check_error() @@ -677,15 +691,15 @@ def text_copy(txt: str) -> Annotated[str, 'text *']: return result if result != _ffi.NULL else None -def text_in(string: str) -> Annotated[str, 'text *']: - string_converted = string.encode('utf-8') +def text_in(string: str) -> Annotated[str, "text *"]: + string_converted = string.encode("utf-8") result = _lib.text_in(string_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def text_initcap(txt: str) -> Annotated[str, 'text *']: +def text_initcap(txt: str) -> Annotated[str, "text *"]: txt_converted = cstring2text(txt) result = _lib.text_initcap(txt_converted) _check_error() @@ -693,7 +707,7 @@ def text_initcap(txt: str) -> Annotated[str, 'text *']: return result if result != _ffi.NULL else None -def text_lower(txt: str) -> Annotated[str, 'text *']: +def text_lower(txt: str) -> Annotated[str, "text *"]: txt_converted = cstring2text(txt) result = _lib.text_lower(txt_converted) _check_error() @@ -701,15 +715,15 @@ def text_lower(txt: str) -> Annotated[str, 'text *']: return result if result != _ffi.NULL else None -def text_out(txt: str) -> Annotated[str, 'char *']: +def text_out(txt: str) -> Annotated[str, "char *"]: 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 text_upper(txt: str) -> Annotated[str, 'text *']: +def text_upper(txt: str) -> Annotated[str, "text *"]: txt_converted = cstring2text(txt) result = _lib.text_upper(txt_converted) _check_error() @@ -717,7 +731,7 @@ def text_upper(txt: str) -> Annotated[str, 'text *']: return result if result != _ffi.NULL else None -def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, 'text *']: +def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, "text *"]: txt1_converted = cstring2text(txt1) txt2_converted = cstring2text(txt2) result = _lib.textcat_text_text(txt1_converted, txt2_converted) @@ -726,722 +740,734 @@ def textcat_text_text(txt1: str, txt2: str) -> Annotated[str, 'text *']: return result if result != _ffi.NULL else None -def timestamptz_shift(t: int, interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[int, 'TimestampTz']: - t_converted = _ffi.cast('TimestampTz', t) - interv_converted = _ffi.cast('const Interval *', interv) +def timestamptz_shift(t: int, interv: Annotated[_ffi.CData, "const Interval *"]) -> Annotated[int, "TimestampTz"]: + t_converted = _ffi.cast("TimestampTz", t) + interv_converted = _ffi.cast("const Interval *", interv) result = _lib.timestamptz_shift(t_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def timestamp_to_date(t: int) -> Annotated[int, 'DateADT']: - t_converted = _ffi.cast('Timestamp', t) +def timestamp_to_date(t: int) -> Annotated[int, "DateADT"]: + t_converted = _ffi.cast("Timestamp", t) result = _lib.timestamp_to_date(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_date(t: int) -> Annotated[int, 'DateADT']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_date(t: int) -> Annotated[int, "DateADT"]: + t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_to_date(t_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def bigintset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def bigintset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: + 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_expand(s: Annotated[_ffi.CData, 'const Span *'], value: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('int64', value) +def bigintspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("int64", value) result = _lib.bigintspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_in(string: str) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') +def bigintspan_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def bigintspan_out(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') +def bigintspanset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def dateset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Set *', s) +def dateset_out(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') +def datespan_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def datespan_out(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') +def datespanset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def floatset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def floatset_out(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: + 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_expand(s: Annotated[_ffi.CData, 'const Span *'], value: float) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: float) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_expand(s_converted, value) _check_error() return result if result != _ffi.NULL else None -def floatspan_in(string: str) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') +def floatspan_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_out(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') +def floatspanset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[str, "char *"]: + 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 intset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def intset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def intset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: + 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_expand(s: Annotated[_ffi.CData, 'const Span *'], value: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('int32', value) +def intspan_expand(s: Annotated[_ffi.CData, "const Span *"], value: int) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("int32", value) result = _lib.intspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_in(string: str) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') +def intspan_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def intspan_out(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') +def intspanset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: + 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: Annotated[_ffi.CData, 'const Set *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_wkb( + s: Annotated[_ffi.CData, "const Set *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_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 return result_converted -def set_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'Set *']: - hexwkb_converted = hexwkb.encode('utf-8') +def set_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_wkb( + s: Annotated[_ffi.CData, "const Span *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_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 return result_converted -def span_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'Span *']: - hexwkb_converted = hexwkb.encode('utf-8') +def span_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const SpanSet *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_wkb( + ss: Annotated[_ffi.CData, "const SpanSet *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_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 return result_converted -def spanset_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'SpanSet *']: - hexwkb_converted = hexwkb.encode('utf-8') +def spanset_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def textset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def textset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def tstzset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def tstzset_out(set: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') +def tstzspan_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_out(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[str, "char *"]: + 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) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') +def tstzspanset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[str, "char *"]: + 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]') -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.new('const int64 []', values) +def bigintset_make(values: "list[const int64]") -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Span *']: - lower_converted = _ffi.cast('int64', lower) - upper_converted = _ffi.cast('int64', upper) +def bigintspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, "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]') -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.new('const DateADT []', values) +def dateset_make(values: "list[const DateADT]") -> Annotated[_ffi.CData, "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: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, 'Span *']: - lower_converted = _ffi.cast('DateADT', lower) - upper_converted = _ffi.cast('DateADT', upper) +def datespan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, "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]') -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.new('const double []', values) +def floatset_make(values: "list[const double]") -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Span *']: +def floatspan_make(lower: float, upper: float, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, "Span *"]: result = _lib.floatspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def intset_make(values: 'list[const int]') -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.new('const int []', values) +def intset_make(values: "list[const int]") -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Span *']: +def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def set_copy(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def span_copy(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_copy(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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[Annotated[_ffi.CData, 'Span *']]) -> Annotated[_ffi.CData, 'SpanSet *']: - spans_converted = _ffi.new('Span []', spans) +def spanset_make(spans: list[Annotated[_ffi.CData, "Span *"]]) -> Annotated[_ffi.CData, "SpanSet *"]: + spans_converted = _ffi.new("Span []", spans) result = _lib.spanset_make(spans_converted, len(spans)) _check_error() return result if result != _ffi.NULL else None -def textset_make(values: list[str]) -> Annotated[_ffi.CData, 'Set *']: +def textset_make(values: list[str]) -> Annotated[_ffi.CData, "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]) -> Annotated[_ffi.CData, 'Set *']: - values_converted = [_ffi.cast('const TimestampTz', x) for x in values] +def tstzset_make(values: list[int]) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, '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) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: - i_converted = _ffi.cast('int64', i) +def bigint_to_set(i: int) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Span *']: +def bigint_to_span(i: int) -> Annotated[_ffi.CData, "Span *"]: result = _lib.bigint_to_span(i) _check_error() return result if result != _ffi.NULL else None -def bigint_to_spanset(i: int) -> Annotated[_ffi.CData, 'SpanSet *']: +def bigint_to_spanset(i: int) -> Annotated[_ffi.CData, "SpanSet *"]: result = _lib.bigint_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def date_to_set(d: int) -> Annotated[_ffi.CData, 'Set *']: - d_converted = _ffi.cast('DateADT', d) +def date_to_set(d: int) -> Annotated[_ffi.CData, "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: int) -> Annotated[_ffi.CData, 'Span *']: - d_converted = _ffi.cast('DateADT', d) +def date_to_span(d: int) -> Annotated[_ffi.CData, "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: int) -> Annotated[_ffi.CData, 'SpanSet *']: - d_converted = _ffi.cast('DateADT', d) +def date_to_spanset(d: int) -> Annotated[_ffi.CData, "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 dateset_to_tstzset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def dateset_to_tstzset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def datespan_to_tstzspan(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_to_tstzspanset(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: +def float_to_set(d: float) -> Annotated[_ffi.CData, "Set *"]: result = _lib.float_to_set(d) _check_error() return result if result != _ffi.NULL else None -def float_to_span(d: float) -> Annotated[_ffi.CData, 'Span *']: +def float_to_span(d: float) -> Annotated[_ffi.CData, "Span *"]: result = _lib.float_to_span(d) _check_error() return result if result != _ffi.NULL else None -def float_to_spanset(d: float) -> Annotated[_ffi.CData, 'SpanSet *']: +def float_to_spanset(d: float) -> Annotated[_ffi.CData, "SpanSet *"]: result = _lib.float_to_spanset(d) _check_error() return result if result != _ffi.NULL else None -def floatset_to_intset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_to_intset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_to_intspan(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_to_intspanset(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 int_to_set(i: int) -> Annotated[_ffi.CData, 'Set *']: +def int_to_set(i: int) -> Annotated[_ffi.CData, "Set *"]: result = _lib.int_to_set(i) _check_error() return result if result != _ffi.NULL else None -def int_to_span(i: int) -> Annotated[_ffi.CData, 'Span *']: +def int_to_span(i: int) -> Annotated[_ffi.CData, "Span *"]: result = _lib.int_to_span(i) _check_error() return result if result != _ffi.NULL else None -def int_to_spanset(i: int) -> Annotated[_ffi.CData, 'SpanSet *']: +def int_to_spanset(i: int) -> Annotated[_ffi.CData, "SpanSet *"]: result = _lib.int_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def intset_to_floatset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intset_to_floatset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def intspan_to_floatspan(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_to_floatspanset(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Set *', s) +def set_to_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 set_to_spanset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Set *', s) +def set_to_spanset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def span_to_spanset(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: +def text_to_set(txt: str) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_set(t: int) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Span *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_span(t: int) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'SpanSet *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_spanset(t: int) -> Annotated[_ffi.CData, "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 tstzset_to_dateset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def tstzset_to_dateset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_to_datespan(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_to_datespanset(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Set *', s) +def bigintset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Set *', s) +def bigintset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, 'int64']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('int64 *') +def bigintset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "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: @@ -1449,72 +1475,72 @@ def bigintset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annota return None -def bigintset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'int64 *']: - s_converted = _ffi.cast('const Set *', s) +def bigintset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Span *', s) +def bigintspan_lower(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Span *', s) +def bigintspan_upper(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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 bigintspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Span *', s) +def bigintspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int64']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_lower(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int64']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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 bigintspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[int, 'int64']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'DateADT']: - s_converted = _ffi.cast('const Set *', s) +def dateset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'DateADT']: - s_converted = _ffi.cast('const Set *', s) +def dateset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, 'DateADT *']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('DateADT *') +def dateset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "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: @@ -1522,37 +1548,37 @@ def dateset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotate return None -def dateset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'DateADT *']: - s_converted = _ffi.cast('const Set *', s) +def dateset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Interval *']: - s_converted = _ffi.cast('const Span *', s) +def datespan_duration(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'DateADT']: - s_converted = _ffi.cast('const Span *', s) +def datespan_lower(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'DateADT']: - s_converted = _ffi.cast('const Span *', s) +def datespan_upper(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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_date_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], n: int) -> Annotated[_ffi.CData, 'DateADT *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - out_result = _ffi.new('DateADT *') +def datespanset_date_n(ss: Annotated[_ffi.CData, "const SpanSet *"], n: int) -> Annotated[_ffi.CData, "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: @@ -1560,58 +1586,60 @@ def datespanset_date_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], n: int) -> return None -def datespanset_dates(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Set *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_dates(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Set *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.datespanset_dates(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_duration(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, 'Interval *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_duration( + ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'DateADT']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_end_date(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_num_dates(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'DateADT']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_start_date(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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 floatset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Set *', s) +def floatset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Set *', s) +def floatset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, 'double']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('double *') +def floatset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "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: @@ -1619,72 +1647,72 @@ def floatset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotat return None -def floatset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'double *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_lower(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_upper(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "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 floatspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_lower(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[float, "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 floatspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[float, "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 intset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) +def intset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) +def intset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, 'int']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('int *') +def intset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "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: @@ -1692,196 +1720,196 @@ def intset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated return None -def intset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'int *']: - s_converted = _ffi.cast('const Set *', s) +def intset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Span *', s) +def intspan_lower(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Span *', s) +def intspan_upper(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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 intspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Span *', s) +def intspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_lower(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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 intspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'uint32']: - s_converted = _ffi.cast('const Set *', s) +def set_hash(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], seed: int) -> Annotated[int, 'uint64']: - s_converted = _ffi.cast('const Set *', s) - seed_converted = _ffi.cast('uint64', seed) +def set_hash_extended(s: Annotated[_ffi.CData, "const Set *"], seed: int) -> Annotated[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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) +def set_num_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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 span_hash(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'uint32']: - s_converted = _ffi.cast('const Span *', s) +def span_hash(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *'], seed: int) -> Annotated[int, 'uint64']: - s_converted = _ffi.cast('const Span *', s) - seed_converted = _ffi.cast('uint64', seed) +def span_hash_extended(s: Annotated[_ffi.CData, "const Span *"], seed: int) -> Annotated[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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def span_lower_inc(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def span_upper_inc(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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 spanset_end_span(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_end_span(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'uint32']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_hash(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *'], seed: int) -> Annotated[int, 'uint64']: - ss_converted = _ffi.cast('const SpanSet *', ss) - seed_converted = _ffi.cast('uint64', seed) +def spanset_hash_extended(ss: Annotated[_ffi.CData, "const SpanSet *"], seed: int) -> Annotated[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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_lower_inc(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_num_spans(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_span(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'Span *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_span_n(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "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_spanarr(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span **']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_spanarr(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Span **"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_spanarr(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_start_span(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_start_span(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_upper_inc(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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 textset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'text *']: - s_converted = _ffi.cast('const Set *', s) +def textset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "text *"]: + 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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[str, 'text *']: - s_converted = _ffi.cast('const Set *', s) +def textset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[str, "text *"]: + 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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, 'text **']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('text **') +def textset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "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: @@ -1889,30 +1917,30 @@ def textset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotate return None -def textset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'text **']: - s_converted = _ffi.cast('const Set *', s) +def textset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'TimestampTz']: - s_converted = _ffi.cast('const Set *', s) +def tstzset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'TimestampTz']: - s_converted = _ffi.cast('const Set *', s) +def tstzset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> int: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('TimestampTz *') +def tstzset_value_n(s: Annotated[_ffi.CData, "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: @@ -1920,79 +1948,81 @@ def tstzset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> int: return None -def tstzset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'TimestampTz *']: - s_converted = _ffi.cast('const Set *', s) +def tstzset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Interval *']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_duration(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'TimestampTz']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_lower(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'TimestampTz']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_upper(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, 'Interval *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_duration( + ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_end_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_lower(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_num_timestamps(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_start_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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_timestamps(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Set *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_timestamps(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "Set *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_timestamps(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], n: int) -> int: - ss_converted = _ffi.cast('const SpanSet *', ss) - out_result = _ffi.new('TimestampTz *') +def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, "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: @@ -2000,3666 +2030,3972 @@ def tstzspanset_timestamptz_n(ss: Annotated[_ffi.CData, 'const SpanSet *'], n: i return None -def tstzspanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) +def bigintset_shift_scale( + s: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) +def bigintspan_shift_scale( + s: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) +def bigintspanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def dateset_shift_scale( + s: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 datespan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def datespan_shift_scale( + s: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 datespanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 floatset_ceil(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_ceil(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_ceil(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_degrees(s: Annotated[_ffi.CData, 'const Set *'], normalize: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_degrees(s: Annotated[_ffi.CData, "const Set *"], normalize: bool) -> Annotated[_ffi.CData, "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_floor(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_floor(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_floor(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_radians(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_radians(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def floatset_shift_scale( + s: Annotated[_ffi.CData, "const Set *"], shift: float, width: float, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 floatspan_ceil(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_ceil(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_ceil(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_degrees(s: Annotated[_ffi.CData, 'const Span *'], normalize: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_degrees(s: Annotated[_ffi.CData, "const Span *"], normalize: bool) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_degrees(s_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def floatspan_floor(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_floor(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_floor(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_radians(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_radians(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_radians(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_round(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_round(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def floatspan_shift_scale( + s: Annotated[_ffi.CData, "const Span *"], shift: float, width: float, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 floatspanset_ceil(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_ceil(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_ceil(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_floor(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_floor(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_floor(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_degrees(ss: Annotated[_ffi.CData, 'const SpanSet *'], normalize: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_degrees( + ss: Annotated[_ffi.CData, "const SpanSet *"], normalize: bool +) -> Annotated[_ffi.CData, "SpanSet *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_degrees(ss_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def floatspanset_radians(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_radians(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "SpanSet *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_radians(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_round(ss: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_round(ss: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], shift: float, width: float, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 intset_shift_scale(s: Annotated[_ffi.CData, 'const Set *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intset_shift_scale( + s: Annotated[_ffi.CData, "const Set *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 intspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def intspan_shift_scale( + s: Annotated[_ffi.CData, "const Span *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 intspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "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 tstzspan_expand(s: Annotated[_ffi.CData, 'const Span *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - interv_converted = _ffi.cast('const Interval *', interv) +def tstzspan_expand( + s: Annotated[_ffi.CData, "const Span *"], interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + interv_converted = _ffi.cast("const Interval *", interv) result = _lib.tstzspan_expand(s_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def set_round(s: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def set_round(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.set_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def textcat_text_textset(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: +def textcat_text_textset(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) + 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 textcat_textset_text(s: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def textcat_textset_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "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 textset_initcap(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def textset_initcap(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def textset_lower(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def textset_upper(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[int, 'TimestampTz']: - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def timestamptz_tprecision( + t: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[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: Annotated[_ffi.CData, 'const Set *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Set *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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 tstzset_tprecision(s: Annotated[_ffi.CData, 'const Set *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def tstzset_tprecision( + s: Annotated[_ffi.CData, "const Set *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[_ffi.CData, "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 tstzspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def tstzspan_tprecision( + s: Annotated[_ffi.CData, "const Span *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[_ffi.CData, "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 tstzspanset_shift_scale(ss: Annotated[_ffi.CData, 'const SpanSet *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 +def tstzspanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def tstzspanset_tprecision( + ss: Annotated[_ffi.CData, "const SpanSet *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[_ffi.CData, "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 set_cmp(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_cmp( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_eq( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_ge( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_gt( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_le( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_lt( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def set_ne( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_cmp( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_eq( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_ge( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_gt( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_le( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_lt( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def span_ne( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_cmp( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_eq( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_ge( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_gt( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_le( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_lt( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def spanset_ne( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 set_spans(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Set *', s) +def set_spans(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.set_spans(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_split_each_n_spans(s: Annotated[_ffi.CData, 'const Set *'], elems_per_span: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Set *', s) - count = _ffi.new('int *') +def set_split_each_n_spans( + s: Annotated[_ffi.CData, "const Set *"], elems_per_span: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Set *", s) + count = _ffi.new("int *") result = _lib.set_split_each_n_spans(s_converted, elems_per_span, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def set_split_n_spans(s: Annotated[_ffi.CData, 'const Set *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Set *', s) - count = _ffi.new('int *') +def set_split_n_spans( + s: Annotated[_ffi.CData, "const Set *"], span_count: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Set *", s) + count = _ffi.new("int *") result = _lib.set_split_n_spans(s_converted, span_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def spanset_spans(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_spans(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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_split_each_n_spans(ss: Annotated[_ffi.CData, 'const SpanSet *'], elems_per_span: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') +def spanset_split_each_n_spans( + ss: Annotated[_ffi.CData, "const SpanSet *"], elems_per_span: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") result = _lib.spanset_split_each_n_spans(ss_converted, elems_per_span, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def spanset_split_n_spans(ss: Annotated[_ffi.CData, 'const SpanSet *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') +def spanset_split_n_spans( + ss: Annotated[_ffi.CData, "const SpanSet *"], span_count: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") result = _lib.spanset_split_n_spans(ss_converted, span_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def adjacent_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def adjacent_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def adjacent_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def adjacent_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def adjacent_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def adjacent_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def adjacent_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 adjacent_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def adjacent_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def adjacent_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def adjacent_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def adjacent_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def adjacent_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def adjacent_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def adjacent_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def adjacent_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def contained_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def contained_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def contained_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def contained_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def contained_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def contained_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def contained_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def contained_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def contained_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def contained_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def contained_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def contained_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: +def contained_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def contained_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def contained_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def contains_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def contains_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def contains_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "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_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def contains_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def contains_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: str) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def contains_set_text(s: Annotated[_ffi.CData, "const Set *"], t: str) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def contains_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def contains_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def contains_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def contains_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def contains_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def contains_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contains_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def contains_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def contains_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def contains_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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 contains_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def contains_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def contains_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def contains_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def contains_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def contains_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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 overlaps_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def overlaps_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def overlaps_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overlaps_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 overlaps_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def overlaps_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def overlaps_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def after_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def after_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def after_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def after_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def after_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def after_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def after_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def after_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def after_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def after_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def after_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def after_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def before_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def before_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def before_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def before_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def before_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def before_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def before_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def before_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def before_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def before_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def before_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def before_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def left_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def left_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def left_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def left_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def left_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def left_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def left_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def left_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def left_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def left_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def left_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def left_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def left_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def left_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def left_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def left_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def left_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def left_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: +def left_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def overafter_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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 overafter_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def overafter_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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 overafter_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overafter_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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 overafter_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def overafter_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def overafter_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "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_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def overafter_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def overafter_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def overafter_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def overafter_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def overafter_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def overafter_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overafter_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def overbefore_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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 overbefore_date_span(d: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def overbefore_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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 overbefore_date_spanset(d: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overbefore_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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 overbefore_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def overbefore_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def overbefore_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[bool, "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_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def overbefore_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[bool, "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_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def overbefore_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[bool, "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_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def overbefore_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[bool, "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_spanset_timestamptz(ss: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def overbefore_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[bool, "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_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def overbefore_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def overbefore_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overbefore_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def overleft_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def overleft_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overleft_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overleft_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overleft_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overleft_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def overleft_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overleft_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overleft_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def overleft_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overleft_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def overleft_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overleft_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overleft_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def overleft_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def overleft_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def overleft_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def overleft_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: +def overleft_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def overright_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def overright_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overright_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overright_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overright_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overright_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def overright_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overright_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overright_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def overright_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def overright_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def overright_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overright_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def overright_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def overright_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def overright_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def overright_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def overright_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: +def overright_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def right_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def right_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def right_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def right_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def right_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def right_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def right_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def right_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def right_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def right_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) +def right_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def right_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def right_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) +def right_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def right_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def right_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def right_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def right_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: +def right_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[bool, "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 intersection_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def intersection_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 intersection_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def intersection_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + d_converted = _ffi.cast("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 intersection_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intersection_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 intersection_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intersection_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 intersection_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def intersection_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def intersection_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intersection_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "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_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intersection_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def intersection_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def intersection_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def intersection_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def intersection_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def intersection_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def intersection_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) +def intersection_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def intersection_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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_span_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def intersection_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 intersection_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def intersection_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "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_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def intersection_spanset_bigint( + ss: Annotated[_ffi.CData, "const SpanSet *"], i: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def intersection_spanset_date( + ss: Annotated[_ffi.CData, "const SpanSet *"], d: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intersection_spanset_float( + ss: Annotated[_ffi.CData, "const SpanSet *"], d: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intersection_spanset_int( + ss: Annotated[_ffi.CData, "const SpanSet *"], i: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def intersection_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def intersection_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def intersection_spanset_timestamptz( + ss: Annotated[_ffi.CData, "const SpanSet *"], t: int +) -> Annotated[_ffi.CData, "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 intersection_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: +def intersection_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) + 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 intersection_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def intersection_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + t_converted = _ffi.cast("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 minus_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def minus_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) +def minus_bigint_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def minus_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) +def minus_date_span(d: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_date_spanset(d: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def minus_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def minus_float_span(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_float_spanset(d: float, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def minus_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def minus_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_int_spanset(i: int, ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def minus_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def minus_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def minus_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "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_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def minus_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def minus_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def minus_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def minus_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def minus_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def minus_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def minus_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def minus_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def minus_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def minus_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def minus_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def minus_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def minus_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def minus_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def minus_spanset_timestamptz( + ss: Annotated[_ffi.CData, "const SpanSet *"], t: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: +def minus_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def minus_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 minus_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def minus_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_timestamptz_spanset( + t: int, ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 union_bigint_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) +def union_bigint_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 union_bigint_span(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def union_bigint_span(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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 union_bigint_spanset(i: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('SpanSet *', ss) +def union_bigint_spanset(i: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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 union_date_set(d: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) +def union_date_set(d: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + d_converted = _ffi.cast("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 union_date_span(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def union_date_span(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "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 union_date_spanset(d: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('SpanSet *', ss) +def union_date_spanset(d: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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 union_float_set(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def union_float_set(d: float, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 union_float_span(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def union_float_span(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "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 union_float_spanset(d: float, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('SpanSet *', ss) +def union_float_spanset(d: float, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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 union_int_set(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def union_int_set(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 union_int_span(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def union_int_span(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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 union_int_spanset(i: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('SpanSet *', ss) +def union_int_spanset(i: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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 union_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def union_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def union_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def union_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[_ffi.CData, "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_int(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def union_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def union_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], txt: str) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def union_set_text(s: Annotated[_ffi.CData, "const Set *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def union_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def union_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def union_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def union_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) +def union_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def union_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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_spanset(s: Annotated[_ffi.CData, 'const Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) +def union_span_spanset( + s: Annotated[_ffi.CData, "const Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 union_span_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def union_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def union_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def union_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def union_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def union_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def union_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def union_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def union_spanset_timestamptz( + ss: Annotated[_ffi.CData, "const SpanSet *"], t: int +) -> Annotated[_ffi.CData, "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 union_text_set(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: +def union_text_set(txt: str, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) + 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 union_timestamptz_set(t: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) +def union_timestamptz_set(t: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + t_converted = _ffi.cast("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 union_timestamptz_span(t: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) +def union_timestamptz_span(t: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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 union_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('SpanSet *', ss) +def union_timestamptz_spanset(t: int, ss: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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 distance_bigintset_bigintset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int64']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_bigintset_bigintset( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[int, "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 distance_bigintspan_bigintspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int64']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_bigintspan_bigintspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_bigintspanset_bigintspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int64']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_bigintspanset_bigintspan( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_bigintspanset_bigintspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int64']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_bigintspanset_bigintspanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[int, "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 distance_dateset_dateset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_dateset_dateset( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[int, "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 distance_datespan_datespan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_datespan_datespan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_datespanset_datespan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_datespanset_datespan( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_datespanset_datespanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_datespanset_datespanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[int, "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 distance_floatset_floatset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, 'double']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_floatset_floatset( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[float, "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 distance_floatspan_floatspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_floatspan_floatspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[float, "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 distance_floatspanset_floatspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_floatspanset_floatspan( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[float, "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 distance_floatspanset_floatspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, 'double']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_floatspanset_floatspanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[float, "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 distance_intset_intset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_intset_intset( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[int, "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 distance_intspan_intspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_intspan_intspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_intspanset_intspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_intspanset_intspan( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[int, "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 distance_intspanset_intspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_intspanset_intspanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[int, "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 distance_set_bigint(s: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) +def distance_set_bigint(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[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 distance_set_date(s: Annotated[_ffi.CData, 'const Set *'], d: int) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) +def distance_set_date(s: Annotated[_ffi.CData, "const Set *"], d: int) -> Annotated[int, "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 distance_set_float(s: Annotated[_ffi.CData, 'const Set *'], d: float) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Set *', s) +def distance_set_float(s: Annotated[_ffi.CData, "const Set *"], d: float) -> Annotated[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: Annotated[_ffi.CData, 'const Set *'], i: int) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) +def distance_set_int(s: Annotated[_ffi.CData, "const Set *"], i: int) -> Annotated[int, "int"]: + 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_timestamptz(s: Annotated[_ffi.CData, 'const Set *'], t: int) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) +def distance_set_timestamptz(s: Annotated[_ffi.CData, "const Set *"], t: int) -> Annotated[float, "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_span_bigint(s: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[int, 'int64']: - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) +def distance_span_bigint(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[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 distance_span_date(s: Annotated[_ffi.CData, 'const Span *'], d: int) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) +def distance_span_date(s: Annotated[_ffi.CData, "const Span *"], d: int) -> Annotated[int, "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 distance_span_float(s: Annotated[_ffi.CData, 'const Span *'], d: float) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Span *', s) +def distance_span_float(s: Annotated[_ffi.CData, "const Span *"], d: float) -> Annotated[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: Annotated[_ffi.CData, 'const Span *'], i: int) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Span *', s) +def distance_span_int(s: Annotated[_ffi.CData, "const Span *"], i: int) -> Annotated[int, "int"]: + 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_timestamptz(s: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[float, 'double']: - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) +def distance_span_timestamptz(s: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[float, "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_spanset_bigint(ss: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[int, 'int64']: - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) +def distance_spanset_bigint(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[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() return result if result != _ffi.NULL else None -def distance_spanset_date(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: int) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) +def distance_spanset_date(ss: Annotated[_ffi.CData, "const SpanSet *"], d: int) -> Annotated[int, "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() return result if result != _ffi.NULL else None -def distance_spanset_float(ss: Annotated[_ffi.CData, 'const SpanSet *'], d: float) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def distance_spanset_float(ss: Annotated[_ffi.CData, "const SpanSet *"], d: float) -> Annotated[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: Annotated[_ffi.CData, 'const SpanSet *'], i: int) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def distance_spanset_int(ss: Annotated[_ffi.CData, "const SpanSet *"], i: int) -> Annotated[int, "int"]: + 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: Annotated[_ffi.CData, 'const SpanSet *'], t: int) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def distance_spanset_timestamptz(ss: Annotated[_ffi.CData, "const SpanSet *"], t: int) -> Annotated[float, "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_tstzset_tstzset(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[float, 'double']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_tstzset_tstzset( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[float, "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 distance_tstzspan_tstzspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_tstzspan_tstzspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[float, "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 distance_tstzspanset_tstzspan(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_tstzspanset_tstzspan( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[float, "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 distance_tstzspanset_tstzspanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[float, 'double']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_tstzspanset_tstzspanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[float, "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 bigint_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], i: int) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - i_converted = _ffi.cast('int64', i) +def bigint_extent_transfn(state: Annotated[_ffi.CData, "Span *"], i: int) -> Annotated[_ffi.CData, "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 bigint_union_transfn(state: Annotated[_ffi.CData, 'Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - i_converted = _ffi.cast('int64', i) +def bigint_union_transfn(state: Annotated[_ffi.CData, "Set *"], i: int) -> Annotated[_ffi.CData, "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 date_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], d: int) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - d_converted = _ffi.cast('DateADT', d) +def date_extent_transfn(state: Annotated[_ffi.CData, "Span *"], d: int) -> Annotated[_ffi.CData, "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 date_union_transfn(state: Annotated[_ffi.CData, 'Set *'], d: int) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - d_converted = _ffi.cast('DateADT', d) +def date_union_transfn(state: Annotated[_ffi.CData, "Set *"], d: int) -> Annotated[_ffi.CData, "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 float_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], d: float) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) +def float_extent_transfn(state: Annotated[_ffi.CData, "Span *"], d: float) -> Annotated[_ffi.CData, "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 float_union_transfn(state: Annotated[_ffi.CData, 'Set *'], d: float) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) +def float_union_transfn(state: Annotated[_ffi.CData, "Set *"], d: float) -> Annotated[_ffi.CData, "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(state: Annotated[_ffi.CData, 'Span *'], i: int) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) +def int_extent_transfn(state: Annotated[_ffi.CData, "Span *"], i: int) -> Annotated[_ffi.CData, "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 int_union_transfn(state: Annotated[_ffi.CData, 'Set *'], i: int) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - i_converted = _ffi.cast('int32', i) +def int_union_transfn(state: Annotated[_ffi.CData, "Set *"], i: int) -> Annotated[_ffi.CData, "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 set_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - s_converted = _ffi.cast('const Set *', s) +def set_extent_transfn( + state: Annotated[_ffi.CData, "Span *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 set_union_finalfn(state: Annotated[_ffi.CData, 'Set *']) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) +def set_union_finalfn(state: Annotated[_ffi.CData, "Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Set *'], s: Annotated[_ffi.CData, 'Set *']) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - s_converted = _ffi.cast('Set *', s) +def set_union_transfn( + state: Annotated[_ffi.CData, "Set *"], s: Annotated[_ffi.CData, "Set *"] +) -> Annotated[_ffi.CData, "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 span_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - s_converted = _ffi.cast('const Span *', s) +def span_extent_transfn( + state: Annotated[_ffi.CData, "Span *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 span_union_transfn(state: Annotated[_ffi.CData, 'SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - state_converted = _ffi.cast('SpanSet *', state) - s_converted = _ffi.cast('const Span *', s) +def span_union_transfn( + state: Annotated[_ffi.CData, "SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 spanset_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_extent_transfn( + state: Annotated[_ffi.CData, "Span *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 spanset_union_finalfn(state: Annotated[_ffi.CData, 'SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - state_converted = _ffi.cast('SpanSet *', state) +def spanset_union_finalfn(state: Annotated[_ffi.CData, "SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SpanSet *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - state_converted = _ffi.cast('SpanSet *', state) - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_union_transfn( + state: Annotated[_ffi.CData, "SpanSet *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Set *'], txt: str) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) +def text_union_transfn(state: Annotated[_ffi.CData, "Set *"], txt: str) -> Annotated[_ffi.CData, "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(state: Annotated[_ffi.CData, 'Span *'], t: int) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_extent_transfn(state: Annotated[_ffi.CData, "Span *"], t: int) -> Annotated[_ffi.CData, "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 timestamptz_union_transfn(state: Annotated[_ffi.CData, 'Set *'], t: int) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_union_transfn(state: Annotated[_ffi.CData, "Set *"], t: int) -> Annotated[_ffi.CData, "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 bigint_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, 'int64']: - value_converted = _ffi.cast('int64', value) - vsize_converted = _ffi.cast('int64', vsize) - vorigin_converted = _ffi.cast('int64', vorigin) +def bigint_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, "int64"]: + value_converted = _ffi.cast("int64", value) + vsize_converted = _ffi.cast("int64", vsize) + vorigin_converted = _ffi.cast("int64", vorigin) result = _lib.bigint_get_bin(value_converted, vsize_converted, vorigin_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - vsize_converted = _ffi.cast('int64', vsize) - vorigin_converted = _ffi.cast('int64', vorigin) - count = _ffi.new('int *') +def bigintspan_bins( + s: Annotated[_ffi.CData, "const Span *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + vsize_converted = _ffi.cast("int64", vsize) + vorigin_converted = _ffi.cast("int64", vorigin) + count = _ffi.new("int *") result = _lib.bigintspan_bins(s_converted, vsize_converted, vorigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def bigintspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - vsize_converted = _ffi.cast('int64', vsize) - vorigin_converted = _ffi.cast('int64', vorigin) - count = _ffi.new('int *') +def bigintspanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + vsize_converted = _ffi.cast("int64", vsize) + vorigin_converted = _ffi.cast("int64", vorigin) + count = _ffi.new("int *") result = _lib.bigintspanset_bins(ss_converted, vsize_converted, vorigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def date_get_bin(d: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[int, 'DateADT']: - d_converted = _ffi.cast('DateADT', d) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('DateADT', torigin) +def date_get_bin( + d: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[int, "DateADT"]: + d_converted = _ffi.cast("DateADT", d) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("DateADT", torigin) result = _lib.date_get_bin(d_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_bins(s: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('DateADT', torigin) - count = _ffi.new('int *') +def datespan_bins( + s: Annotated[_ffi.CData, "const Span *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("DateADT", torigin) + count = _ffi.new("int *") result = _lib.datespan_bins(s_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def datespanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('DateADT', torigin) - count = _ffi.new('int *') +def datespanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("DateADT", torigin) + count = _ffi.new("int *") result = _lib.datespanset_bins(ss_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def float_get_bin(value: float, vsize: float, vorigin: float) -> Annotated[float, 'double']: +def float_get_bin(value: float, vsize: float, vorigin: float) -> Annotated[float, "double"]: result = _lib.float_get_bin(value, vsize, vorigin) _check_error() return result if result != _ffi.NULL else None -def floatspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - count = _ffi.new('int *') +def floatspan_bins( + s: Annotated[_ffi.CData, "const Span *"], vsize: float, vorigin: float +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + count = _ffi.new("int *") result = _lib.floatspan_bins(s_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def floatspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') +def floatspanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: float, vorigin: float +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") result = _lib.floatspanset_bins(ss_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def int_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, 'int']: +def int_get_bin(value: int, vsize: int, vorigin: int) -> Annotated[int, "int"]: result = _lib.int_get_bin(value, vsize, vorigin) _check_error() return result if result != _ffi.NULL else None -def intspan_bins(s: Annotated[_ffi.CData, 'const Span *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - count = _ffi.new('int *') +def intspan_bins( + s: Annotated[_ffi.CData, "const Span *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + count = _ffi.new("int *") result = _lib.intspan_bins(s_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def intspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') +def intspanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") result = _lib.intspanset_bins(ss_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def timestamptz_get_bin(t: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[int, 'TimestampTz']: - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def timestamptz_get_bin( + t: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[int, "TimestampTz"]: + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) result = _lib.timestamptz_get_bin(t_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_bins(s: Annotated[_ffi.CData, 'const Span *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - count = _ffi.new('int *') +def tstzspan_bins( + s: Annotated[_ffi.CData, "const Span *"], duration: Annotated[_ffi.CData, "const Interval *"], origin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + count = _ffi.new("int *") result = _lib.tstzspan_bins(s_converted, duration_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tstzspanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tstzspanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tstzspanset_bins(ss_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tbox_as_hexwkb(box: Annotated[_ffi.CData, 'const TBox *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TBox *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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 tbox_as_wkb(box: Annotated[_ffi.CData, 'const TBox *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: - 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: Annotated[_ffi.CData, "const TBox *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: + 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 return result_converted -def tbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'TBox *']: - hexwkb_converted = hexwkb.encode('utf-8') +def tbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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_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_in(string: str) -> Annotated[_ffi.CData, 'TBox *']: - string_converted = string.encode('utf-8') +def tbox_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TBox *'], maxdd: int) -> Annotated[str, 'char *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_out(box: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[str, "char *"]: + 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 float_timestamptz_to_tbox(d: float, t: int) -> Annotated[_ffi.CData, 'TBox *']: - t_converted = _ffi.cast('TimestampTz', t) +def float_timestamptz_to_tbox(d: float, t: int) -> Annotated[_ffi.CData, "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 float_tstzspan_to_tbox(d: float, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TBox *']: - s_converted = _ffi.cast('const Span *', s) +def float_tstzspan_to_tbox(d: float, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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 int_timestamptz_to_tbox(i: int, t: int) -> Annotated[_ffi.CData, 'TBox *']: - t_converted = _ffi.cast('TimestampTz', t) +def int_timestamptz_to_tbox(i: int, t: int) -> Annotated[_ffi.CData, "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 int_tstzspan_to_tbox(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TBox *']: - s_converted = _ffi.cast('const Span *', s) +def int_tstzspan_to_tbox(i: int, s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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 numspan_tstzspan_to_tbox(span: Annotated[_ffi.CData, 'const Span *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TBox *']: - span_converted = _ffi.cast('const Span *', span) - s_converted = _ffi.cast('const Span *', s) +def numspan_tstzspan_to_tbox( + span: Annotated[_ffi.CData, "const Span *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], t: int) -> Annotated[_ffi.CData, 'TBox *']: - span_converted = _ffi.cast('const Span *', span) - t_converted = _ffi.cast('TimestampTz', t) +def numspan_timestamptz_to_tbox(span: Annotated[_ffi.CData, "const Span *"], t: int) -> Annotated[_ffi.CData, "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 tbox_copy(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_copy(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'] | None, p: Annotated[_ffi.CData, 'const Span *'] | None) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"] | None, p: Annotated[_ffi.CData, "const Span *"] | None +) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'TBox *']: +def float_to_tbox(d: float) -> Annotated[_ffi.CData, "TBox *"]: result = _lib.float_to_tbox(d) _check_error() return result if result != _ffi.NULL else None -def int_to_tbox(i: int) -> Annotated[_ffi.CData, 'TBox *']: +def int_to_tbox(i: int) -> Annotated[_ffi.CData, "TBox *"]: result = _lib.int_to_tbox(i) _check_error() return result if result != _ffi.NULL else None -def set_to_tbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TBox *']: - s_converted = _ffi.cast('const Set *', s) +def set_to_tbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TBox *']: - s_converted = _ffi.cast('const Span *', s) +def span_to_tbox(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'TBox *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_to_tbox(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 tbox_to_intspan(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'Span *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_to_intspan(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'Span *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_to_floatspan(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'Span *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_to_tstzspan(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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_tbox(t: int) -> Annotated[_ffi.CData, 'TBox *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_tbox(t: int) -> Annotated[_ffi.CData, "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 tbox_hash(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'uint32']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_hash(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[int, "uint32"]: + box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_hash(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hash_extended(box: Annotated[_ffi.CData, 'const TBox *'], seed: int) -> Annotated[int, 'uint64']: - box_converted = _ffi.cast('const TBox *', box) - seed_converted = _ffi.cast('uint64', seed) +def tbox_hash_extended(box: Annotated[_ffi.CData, "const TBox *"], seed: int) -> Annotated[int, "uint64"]: + box_converted = _ffi.cast("const TBox *", box) + seed_converted = _ffi.cast("uint64", seed) result = _lib.tbox_hash_extended(box_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hast(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_hast(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_hasx(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TBox *']) -> int: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('TimestampTz *') +def tbox_tmax(box: Annotated[_ffi.CData, "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: @@ -5667,9 +6003,9 @@ def tbox_tmax(box: Annotated[_ffi.CData, 'const TBox *']) -> int: return None -def tbox_tmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_tmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5677,9 +6013,9 @@ def tbox_tmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi. return None -def tbox_tmin(box: Annotated[_ffi.CData, 'const TBox *']) -> int: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('TimestampTz *') +def tbox_tmin(box: Annotated[_ffi.CData, "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: @@ -5687,9 +6023,9 @@ def tbox_tmin(box: Annotated[_ffi.CData, 'const TBox *']) -> int: return None -def tbox_tmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_tmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5697,9 +6033,9 @@ def tbox_tmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi. return None -def tbox_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tbox_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5707,9 +6043,9 @@ def tbox_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CDat return None -def tbox_xmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_xmax_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5717,9 +6053,9 @@ def tbox_xmax_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi. return None -def tbox_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tbox_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5727,9 +6063,9 @@ def tbox_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CDat return None -def tbox_xmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_xmin_inc(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5737,9 +6073,9 @@ def tbox_xmin_inc(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi. return None -def tboxfloat_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tboxfloat_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5747,9 +6083,9 @@ def tboxfloat_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi return None -def tboxfloat_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tboxfloat_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5757,9 +6093,9 @@ def tboxfloat_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi return None -def tboxint_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'int']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('int *') +def tboxint_xmax(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5767,9 +6103,9 @@ def tboxint_xmax(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.C return None -def tboxint_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'int']: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('int *') +def tboxint_xmin(box: Annotated[_ffi.CData, "const TBox *"]) -> Annotated[_ffi.CData, "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: @@ -5777,598 +6113,702 @@ def tboxint_xmin(box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.C return None -def tbox_expand_time(box: Annotated[_ffi.CData, 'const TBox *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) - interv_converted = _ffi.cast('const Interval *', interv) +def tbox_expand_time( + box: Annotated[_ffi.CData, "const TBox *"], interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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_round(box: Annotated[_ffi.CData, 'const TBox *'], maxdd: int) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tbox_round(box: Annotated[_ffi.CData, "const TBox *"], maxdd: int) -> Annotated[_ffi.CData, "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_time(box: Annotated[_ffi.CData, 'const TBox *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 +def tbox_shift_scale_time( + box: Annotated[_ffi.CData, "const TBox *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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 tfloatbox_expand(box: Annotated[_ffi.CData, 'const TBox *'], d: float) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tfloatbox_expand(box: Annotated[_ffi.CData, "const TBox *"], d: float) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) result = _lib.tfloatbox_expand(box_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloatbox_shift_scale(box: Annotated[_ffi.CData, 'const TBox *'], shift: float, width: float, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tfloatbox_shift_scale( + box: Annotated[_ffi.CData, "const TBox *"], shift: float, width: float, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) result = _lib.tfloatbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tintbox_expand(box: Annotated[_ffi.CData, 'const TBox *'], i: int) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tintbox_expand(box: Annotated[_ffi.CData, "const TBox *"], i: int) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) result = _lib.tintbox_expand(box_converted, i) _check_error() return result if result != _ffi.NULL else None -def tintbox_shift_scale(box: Annotated[_ffi.CData, 'const TBox *'], shift: int, width: int, hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) +def tintbox_shift_scale( + box: Annotated[_ffi.CData, "const TBox *"], shift: int, width: int, hasshift: bool, haswidth: bool +) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) result = _lib.tintbox_shift_scale(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def union_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *'], strict: bool) -> Annotated[_ffi.CData, 'TBox *']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def union_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"], strict: bool +) -> Annotated[_ffi.CData, "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 intersection_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'TBox *']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def intersection_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[_ffi.CData, "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 adjacent_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def adjacent_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 contained_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def contained_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 contains_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def contains_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 overlaps_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overlaps_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def same_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 after_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def after_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 before_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def before_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 left_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def left_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 overafter_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overafter_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 overbefore_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overbefore_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 overleft_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overleft_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 overright_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overright_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 right_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def right_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 tbox_cmp(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'int']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_cmp( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[int, "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_eq(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_eq( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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_ge(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_ge( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_gt( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 tbox_le(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_le( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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_lt(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_lt( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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_ne(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_ne( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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 tbool_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tbool_from_mfjson(string: str) -> Annotated[_ffi.CData, "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 tbool_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tbool_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_out(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: + 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: Annotated[_ffi.CData, 'const Temporal *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], with_bbox: bool, flags: int, precision: int, srs: str | None) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) - srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL +def temporal_as_mfjson( + temp: Annotated[_ffi.CData, "const Temporal *"], with_bbox: bool, flags: int, precision: int, srs: str | None +) -> Annotated[str, "char *"]: + 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: Annotated[_ffi.CData, 'const Temporal *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, '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_wkb( + temp: Annotated[_ffi.CData, "const Temporal *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "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_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_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'Temporal *']: - hexwkb_converted = hexwkb.encode('utf-8') +def temporal_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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_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_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tfloat_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tfloat_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tfloat_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + 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 tint_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tint_from_mfjson(string: str) -> Annotated[_ffi.CData, "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 tint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tint_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_out(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: + 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 ttext_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def ttext_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.ttext_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def ttext_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_out(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "char *"]: + 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 tbool_from_base_temp(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_from_base_temp( + b: bool, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'TInstant *']: - t_converted = _ffi.cast('TimestampTz', t) +def tboolinst_make(b: bool, t: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Set *', s) +def tboolseq_from_base_tstzset( + b: bool, s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Span *', s) +def tboolseq_from_base_tstzspan( + b: bool, s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tboolseqset_from_base_tstzspanset( + b: bool, ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_copy(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_from_base_temp( + d: float, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'TInstant *']: - t_converted = _ffi.cast('TimestampTz', t) +def tfloatinst_make(d: float, t: int) -> Annotated[_ffi.CData, "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_tstzset(d: float, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Set *', s) +def tfloatseq_from_base_tstzset( + d: float, s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 tfloatseq_from_base_tstzspan(d: float, s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Span *', s) +def tfloatseq_from_base_tstzspan( + d: float, s: Annotated[_ffi.CData, "const Span *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + s_converted = _ffi.cast("const Span *", s) result = _lib.tfloatseq_from_base_tstzspan(d, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_from_base_tstzspanset(d: float, ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tfloatseqset_from_base_tstzspanset( + d: float, ss: Annotated[_ffi.CData, "const SpanSet *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tfloatseqset_from_base_tstzspanset(d, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tint_from_base_temp(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_from_base_temp(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'TInstant *']: - t_converted = _ffi.cast('TimestampTz', t) +def tintinst_make(i: int, t: int) -> Annotated[_ffi.CData, "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_tstzset(i: int, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Set *', s) +def tintseq_from_base_tstzset(i: int, s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 tintseq_from_base_tstzspan(i: int, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TSequence *']: - s_converted = _ffi.cast('const Span *', s) +def tintseq_from_base_tstzspan( + i: int, s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 tintseqset_from_base_tstzspanset(i: int, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tintseqset_from_base_tstzspanset( + i: int, ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 tsequence_make(instants: Annotated[list, 'TInstant **'], count: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] +def tsequence_make( + instants: Annotated[list, "TInstant **"], + count: int, + lower_inc: bool, + upper_inc: bool, + interp: InterpolationType, + normalize: bool, +) -> Annotated[_ffi.CData, "TSequence *"]: + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tsequence_make(instants_converted, count, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make(sequences: Annotated[list, 'TSequence **'], count: int, normalize: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] +def tsequenceset_make( + sequences: Annotated[list, "TSequence **"], count: int, normalize: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + sequences_converted = [_ffi.cast("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: Annotated[list, 'TInstant **'], interp: InterpolationType, maxt: Annotated[_ffi.CData, 'const Interval *'] | None, maxdist: float) -> Annotated[_ffi.CData, 'TSequenceSet *']: - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] - maxt_converted = _ffi.cast('const Interval *', maxt) if maxt is not None else _ffi.NULL +def tsequenceset_make_gaps( + instants: Annotated[list, "TInstant **"], + interp: InterpolationType, + maxt: Annotated[_ffi.CData, "const Interval *"] | None, + maxdist: float, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] + maxt_converted = _ffi.cast("const Interval *", maxt) if maxt is not None else _ffi.NULL result = _lib.tsequenceset_make_gaps(instants_converted, len(instants), interp, maxt_converted, maxdist) _check_error() return result if result != _ffi.NULL else None -def ttext_from_base_temp(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def ttext_from_base_temp( + txt: str, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'TInstant *']: +def ttextinst_make(txt: str, t: int) -> Annotated[_ffi.CData, "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_tstzset(txt: str, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: +def ttextseq_from_base_tstzset( + txt: str, s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 ttextseq_from_base_tstzspan(txt: str, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TSequence *']: +def ttextseq_from_base_tstzspan( + txt: str, s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 ttextseqset_from_base_tstzspanset(txt: str, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: +def ttextseqset_from_base_tstzspanset( + txt: str, ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 tbool_to_tint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_to_tint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_to_tint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Span *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tstzspan(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_to_tint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_to_tfloat(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Span *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_to_span(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 tnumber_to_tbox(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TBox *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_to_tbox(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 tbool_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "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_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('bool *') +def tbool_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -6376,9 +6816,9 @@ def tbool_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], return None -def tbool_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('bool *') +def tbool_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("bool *") result = _lib.tbool_value_n(temp_converted, n, out_result) _check_error() if result: @@ -6386,200 +6826,223 @@ def tbool_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> An return None -def tbool_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'bool *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tbool_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "bool *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], boundspan: bool) -> Annotated[_ffi.CData, 'Interval *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_duration( + temp: Annotated[_ffi.CData, "const Temporal *"], boundspan: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TSequence *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_sequence(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'TimestampTz']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_timestamptz(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'uint32']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_hash(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_instant_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TInstant **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_instants( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "TInstant **"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'const char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_interp(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "const char *"]: + 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_lower_inc(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_lower_inc(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: + 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_max_instant(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_max_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_min_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_instants(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_sequences(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_timestamps(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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_segm_duration(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], atleast: bool, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) +def temporal_segm_duration( + temp: Annotated[_ffi.CData, "const Temporal *"], + duration: Annotated[_ffi.CData, "const Interval *"], + atleast: bool, + strict: bool, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) result = _lib.temporal_segm_duration(temp_converted, duration_converted, atleast, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_segments(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_segments( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'TSequence *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_sequence_n( + temp: Annotated[_ffi.CData, "const Temporal *"], i: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_sequences( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_instant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TSequence *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_sequence(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'TimestampTz']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_timestamptz(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *'], maxdist: float, minduration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) - minduration_converted = _ffi.cast('const Interval *', minduration) +def temporal_stops( + temp: Annotated[_ffi.CData, "const Temporal *"], + maxdist: float, + minduration: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'const char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_subtype(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "const char *"]: + 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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'SpanSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_time(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_timestamps(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_timestamps( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[int, "TimestampTz *"], Annotated[_ffi.CData, "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 temporal_timestamptz_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> int: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('TimestampTz *') +def temporal_timestamptz_n(temp: Annotated[_ffi.CData, "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: @@ -6587,45 +7050,47 @@ def temporal_timestamptz_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: i return None -def temporal_upper_inc(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_upper_inc(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "bool"]: + 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 tfloat_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('double *') +def tfloat_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -6633,9 +7098,9 @@ def tfloat_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], return None -def tfloat_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('double *') +def tfloat_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("double *") result = _lib.tfloat_value_n(temp_converted, n, out_result) _check_error() if result: @@ -6643,46 +7108,50 @@ def tfloat_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> A return None -def tfloat_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'double *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tfloat_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "double *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('int *') +def tint_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -6690,9 +7159,9 @@ def tint_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t return None -def tint_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('int *') +def tint_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("int *") result = _lib.tint_value_n(temp_converted, n, out_result) _check_error() if result: @@ -6700,78 +7169,82 @@ def tint_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Ann return None -def tint_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'int *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tint_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "int *"], Annotated[_ffi.CData, "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_avg_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_avg_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnumber_avg_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_integral(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_integral(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_twavg(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'SpanSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_valuespans(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 ttext_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: + 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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: + 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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: + 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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[str, 'text *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[str, "text *"]: + 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_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[list, 'text **']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('text **') +def ttext_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[list, "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: @@ -6779,9 +7252,9 @@ def ttext_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], return None -def ttext_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[list, 'text **']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('text **') +def ttext_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[list, "text **"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("text **") result = _lib.ttext_value_n(temp_converted, n, out_result) _check_error() if result: @@ -6789,3860 +7262,4424 @@ def ttext_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> An return None -def ttext_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'text **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def ttext_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "text **"], Annotated[_ffi.CData, "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 float_degrees(value: float, normalize: bool) -> Annotated[float, 'double']: +def float_degrees(value: float, normalize: bool) -> Annotated[float, "double"]: result = _lib.float_degrees(value, normalize) _check_error() return result if result != _ffi.NULL else None -def temparr_round(temp: Annotated[list, 'Temporal **'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'Temporal **']: - temp_converted = [_ffi.cast('Temporal *', x) for x in temp] +def temparr_round(temp: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "Temporal **"]: + temp_converted = [_ffi.cast("Temporal *", x) for x in temp] result = _lib.temparr_round(temp_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def temporal_round(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_round(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_round(temp_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def temporal_scale_time(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) +def temporal_scale_time( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_set_interp( + temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_set_interp(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_scale_time(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 +def temporal_shift_scale_time( + temp: Annotated[_ffi.CData, "const Temporal *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - shift_converted = _ffi.cast('const Interval *', shift) +def temporal_shift_time( + temp: Annotated[_ffi.CData, "const Temporal *"], shift: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tinstant(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tsequence( + temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_to_tsequence(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequenceset(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tsequenceset( + temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_to_tsequenceset(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloat_ceil(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_ceil(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_ceil(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_degrees(temp: Annotated[_ffi.CData, 'const Temporal *'], normalize: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_degrees( + temp: Annotated[_ffi.CData, "const Temporal *"], normalize: bool +) -> Annotated[_ffi.CData, "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_floor(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_floor(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_floor(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_radians(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_radians(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 tfloat_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], width: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_scale_value( + temp: Annotated[_ffi.CData, "const Temporal *"], width: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], shift: float, width: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_shift_scale_value( + temp: Annotated[_ffi.CData, "const Temporal *"], shift: float, width: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], shift: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_shift_value( + temp: Annotated[_ffi.CData, "const Temporal *"], shift: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], width: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_scale_value( + temp: Annotated[_ffi.CData, "const Temporal *"], width: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], shift: int, width: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_shift_scale_value( + temp: Annotated[_ffi.CData, "const Temporal *"], shift: int, width: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], shift: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_shift_value( + temp: Annotated[_ffi.CData, "const Temporal *"], shift: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Temporal *'], inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType, maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'] | None, expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('Temporal *', temp) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) if maxt is not None else _ffi.NULL +def temporal_append_tinstant( + temp: Annotated[_ffi.CData, "Temporal *"], + inst: Annotated[_ffi.CData, "const TInstant *"], + interp: InterpolationType, + maxdist: float, + maxt: Annotated[_ffi.CData, "const Interval *"] | None, + expand: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("Temporal *", temp) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("const Interval *", maxt) if maxt is not None else _ffi.NULL result = _lib.temporal_append_tinstant(temp_converted, inst_converted, interp, maxdist, maxt_converted, expand) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tsequence(temp: Annotated[_ffi.CData, 'Temporal *'], seq: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('Temporal *', temp) - seq_converted = _ffi.cast('const TSequence *', seq) +def temporal_append_tsequence( + temp: Annotated[_ffi.CData, "Temporal *"], seq: Annotated[_ffi.CData, "const TSequence *"], expand: bool +) -> Annotated[_ffi.CData, "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_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_delete_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_delete_tstzset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"], connect: bool +) -> Annotated[_ffi.CData, "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_delete_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_delete_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_delete_tstzspanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], connect: bool +) -> Annotated[_ffi.CData, "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_insert(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_insert( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_merge( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[list, 'Temporal **'], count: int) -> Annotated[_ffi.CData, 'Temporal *']: - temparr_converted = [_ffi.cast('Temporal *', x) for x in temparr] +def temporal_merge_array(temparr: Annotated[list, "Temporal **"], count: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_update( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_minus_value(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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 temporal_after_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_after_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.temporal_after_timestamptz(temp_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_at_max(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_at_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_at_min(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_at_tstzset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_at_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_at_tstzspanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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_values(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_at_values( + temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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_before_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_before_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.temporal_before_timestamptz(temp_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_max(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_minus_max(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_minus_min(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_minus_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_minus_tstzset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_minus_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_minus_tstzspanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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_values(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_minus_values( + temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_minus_value( + temp: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "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 tint_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_minus_value(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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 tnumber_at_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) +def tnumber_at_span( + temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumber_at_spanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def tnumber_at_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) +def tnumber_minus_span( + temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumber_minus_spanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def tnumber_minus_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[_ffi.CData, "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 ttext_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_at_value(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_minus_value(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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 temporal_cmp(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_cmp( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_eq( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_ge( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_gt( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_le( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_lt( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_ne( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 always_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_eq_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_eq_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "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 always_eq_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_eq_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_eq_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_eq_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_eq_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 always_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_ge_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_ge_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_ge_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_ge_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_ge_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_ge_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.always_ge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_gt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_gt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_gt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_gt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_gt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_gt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.always_gt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_le_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_le_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_le_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_le_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_le_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_le_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.always_le_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_lt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_lt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_lt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_lt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_lt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_lt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.always_lt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_ne_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 always_ne_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "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 always_ne_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_ne_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def always_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 always_ne_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 always_ne_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 always_ne_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_eq_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_eq_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "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 ever_eq_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_eq_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_eq_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_eq_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_eq_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_eq_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_ge_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_ge_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_ge_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_ge_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_ge_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_ge_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_ge_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_gt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_gt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_gt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_gt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_gt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_gt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_gt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_le_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_le_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_le_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_le_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_le_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_le_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_le_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_lt_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_lt_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_lt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_lt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_lt_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_lt_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_lt_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 ever_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_ne_int_tint(i: int, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "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 ever_ne_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[int, "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 ever_ne_temporal_temporal(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_ne_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: +def ever_ne_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int"]: txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + 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 ever_ne_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[int, "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 ever_ne_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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 ever_ne_ttext_text(temp: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[int, "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 teq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def teq_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def teq_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tge_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tge_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tge_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def tge_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tge_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tge_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tge_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tgt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def tgt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tle_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tle_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tle_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def tle_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tle_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tle_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tle_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tlt_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tlt_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tlt_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def tlt_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tlt_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tlt_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tlt_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_float_tfloat(d: float, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_int_tint(i: int, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_tbool_bool(temp: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tne_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def tne_text_ttext(txt: str, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[_ffi.CData, "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_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_ttext_text(temp: Annotated[_ffi.CData, "const Temporal *"], txt: str) -> Annotated[_ffi.CData, "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 temporal_spans(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_spans( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_spans(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_split_each_n_spans(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_split_each_n_spans( + temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_split_each_n_spans(temp_converted, elem_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_split_n_spans(temp: Annotated[_ffi.CData, 'const Temporal *'], span_count: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_split_n_spans( + temp: Annotated[_ffi.CData, "const Temporal *"], span_count: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_split_n_spans(temp_converted, span_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_split_each_n_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tnumber_split_each_n_tboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tnumber_split_each_n_tboxes(temp_converted, elem_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_split_n_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tnumber_split_n_tboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], box_count: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tnumber_split_n_tboxes(temp_converted, box_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_tboxes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tnumber_tboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tnumber_tboxes(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def adjacent_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def adjacent_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def adjacent_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def adjacent_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def adjacent_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def adjacent_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def adjacent_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def adjacent_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def adjacent_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def contained_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def contained_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contained_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def contained_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def contained_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def contained_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contained_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def contained_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def contains_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def contains_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def contains_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contains_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def contains_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def contains_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contains_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def contains_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overlaps_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overlaps_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overlaps_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overlaps_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overlaps_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def overlaps_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overlaps_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overlaps_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def same_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def same_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def same_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def same_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def same_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def same_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def same_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def same_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 after_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def after_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def after_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def after_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def after_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def after_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def after_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 before_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def before_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def before_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def before_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def before_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def before_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def before_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 left_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def left_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def left_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def left_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def left_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def left_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 overafter_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overafter_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overafter_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overafter_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def overafter_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overafter_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overafter_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 overbefore_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overbefore_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overbefore_temporal_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overbefore_temporal_temporal( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def overbefore_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overbefore_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tstzspan_temporal(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overbefore_tstzspan_temporal( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 overleft_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overleft_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overleft_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overleft_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def overleft_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overleft_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 overright_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def overright_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overright_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def overright_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def overright_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overright_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 right_numspan_tnumber(s: Annotated[_ffi.CData, 'const Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def right_numspan_tnumber( + s: Annotated[_ffi.CData, "const Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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_tbox_tnumber(box: Annotated[_ffi.CData, 'const TBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def right_tbox_tnumber( + box: Annotated[_ffi.CData, "const TBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def right_tnumber_numspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def right_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def right_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "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 tand_bool_tbool(b: bool, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tand_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tand_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tand_tbool_tbool( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'SpanSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_when_true(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnot_tbool(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tor_bool_tbool(b: bool, temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], b: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tor_tbool_bool(temp: Annotated[_ffi.CData, "const Temporal *"], b: bool) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tor_tbool_tbool( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def add_float_tfloat( + d: float, tnumber: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def add_int_tint(i: int, tnumber: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def add_tfloat_float( + tnumber: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def add_tint_int(tnumber: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) +def add_tnumber_tnumber( + tnumber1: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def div_float_tfloat( + d: float, tnumber: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def div_int_tint(i: int, tnumber: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def div_tfloat_float( + tnumber: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def div_tint_int(tnumber: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) +def div_tnumber_tnumber( + tnumber1: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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 mult_float_tfloat(d: float, tnumber: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def mult_float_tfloat( + d: float, tnumber: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def mult_int_tint(i: int, tnumber: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def mult_tfloat_float( + tnumber: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def mult_tint_int(tnumber: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) +def mult_tnumber_tnumber( + tnumber1: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def sub_float_tfloat( + d: float, tnumber: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def sub_int_tint(i: int, tnumber: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def sub_tfloat_float( + tnumber: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber_converted = _ffi.cast('const Temporal *', tnumber) +def sub_tint_int(tnumber: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], tnumber2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) +def sub_tnumber_tnumber( + tnumber1: Annotated[_ffi.CData, "const Temporal *"], tnumber2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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 temporal_derivative(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_derivative(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_derivative(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_exp(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_exp(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_exp(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_ln(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_ln(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_ln(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_log10(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_log10(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_log10(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_abs(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_abs(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_trend(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_trend(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnumber_trend(temp_converted) _check_error() return result if result != _ffi.NULL else None -def float_angular_difference(degrees1: float, degrees2: float) -> Annotated[float, 'double']: +def float_angular_difference(degrees1: float, degrees2: float) -> Annotated[float, "double"]: result = _lib.float_angular_difference(degrees1, degrees2) _check_error() return result if result != _ffi.NULL else None -def tnumber_angular_difference(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_angular_difference(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_delta_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: +def textcat_text_ttext( + txt: str, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], txt: str) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def textcat_ttext_text( + temp: Annotated[_ffi.CData, "const Temporal *"], txt: str +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def textcat_ttext_ttext( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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_initcap(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_initcap(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 ttext_upper(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_upper(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_lower(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 tdistance_tfloat_float(temp: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tdistance_tfloat_float( + temp: Annotated[_ffi.CData, "const Temporal *"], d: float +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tdistance_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tdistance_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tdistance_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tdistance_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tdistance_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tdistance_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tboxfloat_tboxfloat(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, 'double']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def nad_tboxfloat_tboxfloat( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[float, "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 -def nad_tboxint_tboxint(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'int']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def nad_tboxint_tboxint( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const Temporal *'], d: float) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def nad_tfloat_float(temp: Annotated[_ffi.CData, "const Temporal *"], d: float) -> Annotated[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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nad_tfloat_tfloat( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "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_tfloat_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def nad_tfloat_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) result = _lib.nad_tfloat_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_int(temp: Annotated[_ffi.CData, 'const Temporal *'], i: int) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) +def nad_tint_int(temp: Annotated[_ffi.CData, "const Temporal *"], i: int) -> Annotated[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_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def nad_tint_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + 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_tint_tint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nad_tint_tint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 tbool_tand_transfn(state: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Span *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_extent_transfn( + s: Annotated[_ffi.CData, "Span *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, 'Temporal *']: - state_converted = _ffi.cast('SkipList *', state) +def temporal_tagg_finalfn(state: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tfloat_wmax_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tfloat_wmin_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tfloat_wmin_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tfloat_wsum_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tfloat_wsum_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 timestamptz_tcount_transfn(state: Annotated[_ffi.CData, 'SkipList *'] | None, t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, t: int +) -> Annotated[_ffi.CData, "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 tint_tmax_transfn(state: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tint_wmax_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tint_wmin_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tint_wmin_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tint_wsum_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tint_wsum_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tnumber_extent_transfn(box: Annotated[_ffi.CData, 'TBox *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "TBox *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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_tavg_finalfn(state: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, 'Temporal *']: - state_converted = _ffi.cast('SkipList *', state) +def tnumber_tavg_finalfn(state: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'const Temporal *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interv_converted = _ffi.cast('const Interval *', interv) +def tnumber_wavg_transfn( + state: Annotated[_ffi.CData, "SkipList *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + interv: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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 tstzset_tcount_transfn(state: Annotated[_ffi.CData, 'SkipList *'] | None, s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 ttext_tmax_transfn(state: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "SkipList *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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_dp(temp: Annotated[_ffi.CData, 'const Temporal *'], eps_dist: float, synchronized: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_simplify_dp( + temp: Annotated[_ffi.CData, "const Temporal *"], eps_dist: float, synchronized: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], eps_dist: float, synchronized: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_simplify_max_dist( + temp: Annotated[_ffi.CData, "const Temporal *"], eps_dist: float, synchronized: bool +) -> Annotated[_ffi.CData, "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_simplify_min_dist(temp: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_simplify_min_dist( + temp: Annotated[_ffi.CData, "const Temporal *"], dist: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], mint: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - mint_converted = _ffi.cast('const Interval *', mint) +def temporal_simplify_min_tdelta( + temp: Annotated[_ffi.CData, "const Temporal *"], mint: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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_tprecision(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) +def temporal_tprecision( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], origin: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int, interp: InterpolationType) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Temporal *"], + duration: Annotated[_ffi.CData, "const Interval *"], + origin: int, + interp: InterpolationType, +) -> Annotated[_ffi.CData, "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, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_distance(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_dyntimewarp_distance( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Match *'], Annotated[_ffi.CData, 'int']]: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - count = _ffi.new('int *') +def temporal_dyntimewarp_path( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> tuple[Annotated[_ffi.CData, "Match *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_frechet_distance( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Match *'], Annotated[_ffi.CData, 'int']]: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - count = _ffi.new('int *') +def temporal_frechet_path( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> tuple[Annotated[_ffi.CData, "Match *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_hausdorff_distance( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "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 temporal_time_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], origin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - count = _ffi.new('int *') +def temporal_time_bins( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], origin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + count = _ffi.new("int *") result = _lib.temporal_time_bins(temp_converted, duration_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - time_bins = _ffi.new('TimestampTz **') - count = _ffi.new('int *') +def temporal_time_split( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "TimestampTz *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + time_bins = _ffi.new("TimestampTz **") + count = _ffi.new("int *") result = _lib.temporal_time_split(temp_converted, duration_converted, torigin_converted, time_bins, count) _check_error() return result if result != _ffi.NULL else None, time_bins[0], count[0] -def tfloat_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tfloat_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tfloat_time_boxes(temp_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tfloat_value_bins( + temp: Annotated[_ffi.CData, "const Temporal *"], vsize: float, vorigin: float +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tfloat_value_bins(temp_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_value_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tfloat_value_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], vsize: float, vorigin: float +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tfloat_value_boxes(temp_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: float, origin: float) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'double *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - bins = _ffi.new('double **') - count = _ffi.new('int *') +def tfloat_value_split( + temp: Annotated[_ffi.CData, "const Temporal *"], size: float, origin: float +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "double *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + bins = _ffi.new("double **") + count = _ffi.new("int *") result = _lib.tfloat_value_split(temp_converted, size, origin, bins, count) _check_error() return result if result != _ffi.NULL else None, bins[0], count[0] -def tfloat_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tfloat_value_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], + vsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: float, + torigin: int, +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tfloat_value_time_boxes(temp_converted, vsize, duration_converted, vorigin, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'double *'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - value_bins = _ffi.new('double **') - time_bins = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tfloat_value_time_split(temp_converted, vsize, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count) +def tfloat_value_time_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + vsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: float, + torigin: int, +) -> tuple[ + Annotated[_ffi.CData, "Temporal **"], + Annotated[list, "double *"], + Annotated[list, "TimestampTz *"], + Annotated[_ffi.CData, "int"], +]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + value_bins = _ffi.new("double **") + time_bins = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tfloat_value_time_split( + temp_converted, vsize, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count + ) _check_error() return result if result != _ffi.NULL else None, value_bins[0], time_bins[0], count[0] -def tfloatbox_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tfloatbox_time_tiles( + box: Annotated[_ffi.CData, "const TBox *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + box_converted = _ffi.cast("const TBox *", box) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tfloatbox_time_tiles(box_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloatbox_value_tiles(box: Annotated[_ffi.CData, 'const TBox *'], vsize: float, vorigin: float) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - count = _ffi.new('int *') +def tfloatbox_value_tiles( + box: Annotated[_ffi.CData, "const TBox *"], vsize: float, vorigin: float +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + box_converted = _ffi.cast("const TBox *", box) + count = _ffi.new("int *") result = _lib.tfloatbox_value_tiles(box_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloatbox_value_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], vsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: float, torigin: int | None) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL - count = _ffi.new('int *') - result = _lib.tfloatbox_value_time_tiles(box_converted, vsize, duration_converted, vorigin, torigin_converted, count) +def tfloatbox_value_time_tiles( + box: Annotated[_ffi.CData, "const TBox *"], + vsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: float, + torigin: int | None, +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + box_converted = _ffi.cast("const TBox *", box) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL + count = _ffi.new("int *") + result = _lib.tfloatbox_value_time_tiles( + box_converted, vsize, duration_converted, vorigin, torigin_converted, count + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tint_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tint_time_boxes(temp_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tint_value_bins( + temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tint_value_bins(temp_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_value_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tint_value_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tint_value_boxes(temp_converted, vsize, vorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, vorigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'int *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - bins = _ffi.new('int **') - count = _ffi.new('int *') +def tint_value_split( + temp: Annotated[_ffi.CData, "const Temporal *"], vsize: int, vorigin: int +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "int *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + bins = _ffi.new("int **") + count = _ffi.new("int *") result = _lib.tint_value_split(temp_converted, vsize, vorigin, bins, count) _check_error() return result if result != _ffi.NULL else None, bins[0], count[0] -def tint_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: int, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: int, torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tint_value_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], + vsize: int, + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: int, + torigin: int, +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tint_value_time_boxes(temp_converted, vsize, duration_converted, vorigin, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: int, duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: int, torigin: int) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'int *'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - value_bins = _ffi.new('int **') - time_bins = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tint_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count) +def tint_value_time_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + size: int, + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: int, + torigin: int, +) -> tuple[ + Annotated[_ffi.CData, "Temporal **"], + Annotated[list, "int *"], + Annotated[list, "TimestampTz *"], + Annotated[_ffi.CData, "int"], +]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + value_bins = _ffi.new("int **") + time_bins = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tint_value_time_split( + temp_converted, size, duration_converted, vorigin, torigin_converted, value_bins, time_bins, count + ) _check_error() return result if result != _ffi.NULL else None, value_bins[0], time_bins[0], count[0] -def tintbox_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def tintbox_time_tiles( + box: Annotated[_ffi.CData, "const TBox *"], duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + box_converted = _ffi.cast("const TBox *", box) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.tintbox_time_tiles(box_converted, duration_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tintbox_value_tiles(box: Annotated[_ffi.CData, 'const TBox *'], xsize: int, xorigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - count = _ffi.new('int *') +def tintbox_value_tiles( + box: Annotated[_ffi.CData, "const TBox *"], xsize: int, xorigin: int +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + box_converted = _ffi.cast("const TBox *", box) + count = _ffi.new("int *") result = _lib.tintbox_value_tiles(box_converted, xsize, xorigin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tintbox_value_time_tiles(box: Annotated[_ffi.CData, 'const TBox *'], xsize: int, duration: Annotated[_ffi.CData, 'const Interval *'], xorigin: int | None, torigin: int | None) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) +def tintbox_value_time_tiles( + box: Annotated[_ffi.CData, "const TBox *"], + xsize: int, + duration: Annotated[_ffi.CData, "const Interval *"], + xorigin: int | None, + torigin: int | None, +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "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_value_time_tiles(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_value_time_tiles( + box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def tempsubtype_name(subtype: Annotated[_ffi.CData, 'tempSubtype']) -> Annotated[str, 'const char *']: - subtype_converted = _ffi.cast('tempSubtype', subtype) +def tempsubtype_name(subtype: Annotated[_ffi.CData, "tempSubtype"]) -> Annotated[str, "const char *"]: + 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: Annotated[_ffi.CData, 'int16 *']) -> Annotated[bool, 'bool']: - string_converted = string.encode('utf-8') - subtype_converted = _ffi.cast('int16 *', subtype) +def tempsubtype_from_string(string: str, subtype: Annotated[_ffi.CData, "int16 *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosOper']) -> Annotated[str, 'const char *']: - oper_converted = _ffi.cast('meosOper', oper) +def meosoper_name(oper: Annotated[_ffi.CData, "meosOper"]) -> Annotated[str, "const char *"]: + 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) -> Annotated[_ffi.CData, 'meosOper']: - name_converted = name.encode('utf-8') +def meosoper_from_string(name: str) -> Annotated[_ffi.CData, "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: InterpolationType) -> Annotated[str, 'const char *']: +def interptype_name(interp: InterpolationType) -> Annotated[str, "const char *"]: result = _lib.interptype_name(interp) _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) -> Annotated[InterpolationType, 'interpType']: - interp_str_converted = interp_str.encode('utf-8') +def interptype_from_string(interp_str: str) -> Annotated[InterpolationType, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[str, 'const char *']: - type_converted = _ffi.cast('meosType', type) +def meostype_name(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[str, "const char *"]: + 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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def temptype_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def settype_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def spantype_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def spantype_spansettype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def spansettype_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def basetype_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'meosType']: - type_converted = _ffi.cast('meosType', type) +def basetype_settype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "meosType"]: + type_converted = _ffi.cast("meosType", type) result = _lib.basetype_settype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tnumber_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def geo_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def geo_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.geo_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def time_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def time_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def set_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def numset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_numset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def timeset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def set_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_set_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - settype_converted = _ffi.cast('meosType', settype) +def alphanumset_type(settype: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def geoset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_geoset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def spatialset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_spatialset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def span_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def span_canon_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def span_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.span_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def type_span_bbox(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def type_span_bbox(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.type_span_bbox(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_tbox_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def span_tbox_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.span_tbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_span_tbox_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_span_tbox_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_span_tbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def numspan_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def numspan_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_numspan_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def timespan_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def timespan_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def spanset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.spanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def timespanset_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def timespanset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_timespanset_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def temporal_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.temporal_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_continuous(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def temptype_continuous(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def basetype_byvalue(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def basetype_varlength(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int16']: - type_converted = _ffi.cast('meosType', type) +def basetype_length(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[int, "int16"]: + type_converted = _ffi.cast("meosType", type) result = _lib.basetype_length(type_converted) _check_error() return result if result != _ffi.NULL else None -def talpha_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def talpha_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tnumber_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tnumber_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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 ensure_tnumber_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tnumber_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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_spantype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tnumber_spantype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tnumber_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_basetype(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def spatial_basetype(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.spatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tspatial_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tspatial_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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 tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tgeo_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tgeo_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "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 tgeo_type_all(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tgeo_type_all(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tgeo_type_all(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeo_type_all(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tgeo_type_all(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_tgeo_type_all(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tgeometry_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tgeometry_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeometry_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tgeometry_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_tgeometry_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeodetic_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def tgeodetic_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.tgeodetic_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeodetic_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tgeodetic_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_tgeodetic_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_tpoint_type(type: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - type_converted = _ffi.cast('meosType', type) +def ensure_tnumber_tpoint_type(type: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + type_converted = _ffi.cast("meosType", type) result = _lib.ensure_tnumber_tpoint_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def geo_as_ewkb(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], endian: str, size: Annotated[_ffi.CData, 'size_t *']) -> Annotated[_ffi.CData, 'uint8_t *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - endian_converted = endian.encode('utf-8') - size_converted = _ffi.cast('size_t *', size) +def geo_as_ewkb( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], endian: str, size: Annotated[_ffi.CData, "size_t *"] +) -> Annotated[_ffi.CData, "uint8_t *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + endian_converted = endian.encode("utf-8") + size_converted = _ffi.cast("size_t *", size) result = _lib.geo_as_ewkb(gs_converted, endian_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def geo_as_ewkt(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], precision: int) -> Annotated[str, 'char *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_as_ewkt(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], precision: int) -> Annotated[str, "char *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_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 geo_as_geojson(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], option: int, precision: int, srs: str | None) -> Annotated[str, 'char *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL +def geo_as_geojson( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], option: int, precision: int, srs: str | None +) -> Annotated[str, "char *"]: + 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') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geo_as_hexewkb(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], endian: str) -> Annotated[str, 'char *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - endian_converted = endian.encode('utf-8') +def geo_as_hexewkb(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], endian: str) -> Annotated[str, "char *"]: + 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') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geo_as_text(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], precision: int) -> Annotated[str, 'char *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_as_text(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], precision: int) -> Annotated[str, "char *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_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 geo_from_ewkb(wkb: Annotated[_ffi.CData, 'const uint8_t *'], wkb_size: Annotated[_ffi.CData, 'size_t'], srid: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - wkb_converted = _ffi.cast('const uint8_t *', wkb) - wkb_size_converted = _ffi.cast('size_t', wkb_size) - srid_converted = _ffi.cast('int32', srid) +def geo_from_ewkb( + wkb: Annotated[_ffi.CData, "const uint8_t *"], wkb_size: Annotated[_ffi.CData, "size_t"], srid: int +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + wkb_converted = _ffi.cast("const uint8_t *", wkb) + wkb_size_converted = _ffi.cast("size_t", wkb_size) + srid_converted = _ffi.cast("int32", srid) result = _lib.geo_from_ewkb(wkb_converted, wkb_size_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_from_geojson(geojson: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geojson_converted = geojson.encode('utf-8') +def geo_from_geojson(geojson: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geojson_converted = geojson.encode("utf-8") result = _lib.geo_from_geojson(geojson_converted) _check_error() return result if result != _ffi.NULL else None -def geo_from_text(wkt: str, srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - wkt_converted = wkt.encode('utf-8') - srid_converted = _ffi.cast('int32_t', srid) +def geo_from_text(wkt: str, srid: Annotated[_ffi.CData, "int32_t"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + wkt_converted = wkt.encode("utf-8") + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geo_from_text(wkt_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_out(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[str, 'char *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_out(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[str, "char *"]: + 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 geog_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - wkt_converted = wkt.encode('utf-8') +def geog_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + wkt_converted = wkt.encode("utf-8") result = _lib.geog_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geog_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def geog_in(string: str, typmod: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.geog_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def geom_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - wkt_converted = wkt.encode('utf-8') +def geom_from_hexewkb(wkt: str) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + wkt_converted = wkt.encode("utf-8") result = _lib.geom_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geom_in(string: str, typmod: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def geom_in(string: str, typmod: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.geom_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def box3d_make(xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'BOX3D *']: - srid_converted = _ffi.cast('int32_t', srid) +def box3d_make( + xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "BOX3D *"]: + srid_converted = _ffi.cast("int32_t", srid) result = _lib.box3d_make(xmin, xmax, ymin, ymax, zmin, zmax, srid_converted) _check_error() return result if result != _ffi.NULL else None -def box3d_out(box: Annotated[_ffi.CData, 'const BOX3D *'], maxdd: int) -> Annotated[str, 'char *']: - box_converted = _ffi.cast('const BOX3D *', box) +def box3d_out(box: Annotated[_ffi.CData, "const BOX3D *"], maxdd: int) -> Annotated[str, "char *"]: + box_converted = _ffi.cast("const BOX3D *", box) result = _lib.box3d_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 gbox_make(hasz: bool, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float) -> Annotated[_ffi.CData, 'GBOX *']: +def gbox_make( + hasz: bool, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float +) -> Annotated[_ffi.CData, "GBOX *"]: result = _lib.gbox_make(hasz, xmin, xmax, ymin, ymax, zmin, zmax) _check_error() return result if result != _ffi.NULL else None -def gbox_out(box: Annotated[_ffi.CData, 'const GBOX *'], maxdd: int) -> Annotated[str, 'char *']: - box_converted = _ffi.cast('const GBOX *', box) +def gbox_out(box: Annotated[_ffi.CData, "const GBOX *"], maxdd: int) -> Annotated[str, "char *"]: + box_converted = _ffi.cast("const GBOX *", box) result = _lib.gbox_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 geo_copy(g: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geo_copy(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geo_copy(g_converted) _check_error() return result if result != _ffi.NULL else None -def geogpoint_make2d(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - srid_converted = _ffi.cast('int32_t', srid) +def geogpoint_make2d( + srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geogpoint_make2d(srid_converted, x, y) _check_error() return result if result != _ffi.NULL else None -def geogpoint_make3dz(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float, z: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - srid_converted = _ffi.cast('int32_t', srid) +def geogpoint_make3dz( + srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float, z: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geogpoint_make3dz(srid_converted, x, y, z) _check_error() return result if result != _ffi.NULL else None -def geompoint_make2d(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - srid_converted = _ffi.cast('int32_t', srid) +def geompoint_make2d( + srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geompoint_make2d(srid_converted, x, y) _check_error() return result if result != _ffi.NULL else None -def geompoint_make3dz(srid: Annotated[_ffi.CData, 'int32_t'], x: float, y: float, z: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - srid_converted = _ffi.cast('int32_t', srid) +def geompoint_make3dz( + srid: Annotated[_ffi.CData, "int32_t"], x: float, y: float, z: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geompoint_make3dz(srid_converted, x, y, z) _check_error() return result if result != _ffi.NULL else None -def geom_to_geog(geom: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geom_converted = _ffi.cast('const GSERIALIZED *', geom) +def geom_to_geog(geom: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) result = _lib.geom_to_geog(geom_converted) _check_error() return result if result != _ffi.NULL else None -def geog_to_geom(geog: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geog_converted = _ffi.cast('const GSERIALIZED *', geog) +def geog_to_geom(geog: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geog_converted = _ffi.cast("const GSERIALIZED *", geog) result = _lib.geog_to_geom(geog_converted) _check_error() return result if result != _ffi.NULL else None -def geo_is_empty(g: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geo_is_empty(g: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[bool, "bool"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geo_is_empty(g_converted) _check_error() return result if result != _ffi.NULL else None -def geo_is_unitary(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_is_unitary(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[bool, "bool"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_is_unitary(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_typename(type: int) -> Annotated[str, 'const char *']: +def geo_typename(type: int) -> Annotated[str, "const char *"]: result = _lib.geo_typename(type) _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 geog_area(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geog_area(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geog_area(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_centroid(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geog_centroid( + g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geog_centroid(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_length(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geog_length(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geog_length(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_perimeter(g: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[float, 'double']: - g_converted = _ffi.cast('const GSERIALIZED *', g) +def geog_perimeter(g: Annotated[_ffi.CData, "const GSERIALIZED *"], use_spheroid: bool) -> Annotated[float, "double"]: + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.geog_perimeter(g_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geom_azimuth(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'double']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) - out_result = _ffi.new('double *') +def geom_azimuth( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "double"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) + out_result = _ffi.new("double *") result = _lib.geom_azimuth(gs1_converted, gs2_converted, out_result) _check_error() if result: @@ -10650,457 +11687,537 @@ def geom_azimuth(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotat return None -def geom_length(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_length(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[float, "double"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_length(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_perimeter(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_perimeter(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[float, "double"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_perimeter(gs_converted) _check_error() return result if result != _ffi.NULL else None -def line_numpoints(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def line_numpoints(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.line_numpoints(gs_converted) _check_error() return result if result != _ffi.NULL else None -def line_point_n(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], n: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geom_converted = _ffi.cast('const GSERIALIZED *', geom) +def line_point_n(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) result = _lib.line_point_n(geom_converted, n) _check_error() return result if result != _ffi.NULL else None -def geo_reverse(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_reverse(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_reverse(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_round(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], maxdd: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_round(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], maxdd: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_round(gs_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def geo_set_srid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - srid_converted = _ffi.cast('int32_t', srid) +def geo_set_srid( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.geo_set_srid(gs_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geo_srid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'int32_t']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_srid(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "int32_t"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_srid(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_transform(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], srid_to: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geom_converted = _ffi.cast('const GSERIALIZED *', geom) - srid_to_converted = _ffi.cast('int32_t', srid_to) +def geo_transform( + geom: Annotated[_ffi.CData, "const GSERIALIZED *"], srid_to: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) + srid_to_converted = _ffi.cast("int32_t", srid_to) result = _lib.geo_transform(geom_converted, srid_to_converted) _check_error() return result if result != _ffi.NULL else None -def geo_transform_pipeline(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], pipeline: str, srid_to: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - pipeline_converted = pipeline.encode('utf-8') - srid_to_converted = _ffi.cast('int32_t', srid_to) +def geo_transform_pipeline( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + pipeline: str, + srid_to: Annotated[_ffi.CData, "int32_t"], + is_forward: bool, +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + pipeline_converted = pipeline.encode("utf-8") + srid_to_converted = _ffi.cast("int32_t", srid_to) result = _lib.geo_transform_pipeline(gs_converted, pipeline_converted, srid_to_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def geo_collect_garray(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] +def geo_collect_garray(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] result = _lib.geo_collect_garray(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geo_makeline_garray(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] +def geo_makeline_garray(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] result = _lib.geo_makeline_garray(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geo_num_points(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_num_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_num_points(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_num_geos(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_num_geos(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_num_geos(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geo_geo_n(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], n: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geom_converted = _ffi.cast('const GSERIALIZED *', geom) +def geo_geo_n(geom: Annotated[_ffi.CData, "const GSERIALIZED *"], n: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) result = _lib.geo_geo_n(geom_converted, n) _check_error() return result if result != _ffi.NULL else None -def geo_pointarr(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - count = _ffi.new('int *') +def geo_pointarr( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], +) -> tuple[Annotated[_ffi.CData, "GSERIALIZED **"], Annotated[_ffi.CData, "int"]]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + count = _ffi.new("int *") result = _lib.geo_pointarr(gs_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geo_points(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_points(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_points(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_array_union(gsarr: Annotated[list, 'GSERIALIZED **'], count: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] +def geom_array_union(gsarr: Annotated[list, "GSERIALIZED **"], count: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] result = _lib.geom_array_union(gsarr_converted, count) _check_error() return result if result != _ffi.NULL else None -def geom_boundary(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_boundary(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_boundary(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_buffer(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], size: float, params: str) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - params_converted = params.encode('utf-8') +def geom_buffer( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], size: float, params: str +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + params_converted = params.encode("utf-8") result = _lib.geom_buffer(gs_converted, size, params_converted) _check_error() return result if result != _ffi.NULL else None -def geom_centroid(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_centroid(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_centroid(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_convex_hull(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_convex_hull(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_convex_hull(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_difference2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_difference2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_difference2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersection2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_intersection2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_intersection2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersection2d_coll(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_intersection2d_coll( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_intersection2d_coll(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_min_bounding_radius(geom: Annotated[_ffi.CData, 'const GSERIALIZED *'], radius: Annotated[_ffi.CData, 'double *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - geom_converted = _ffi.cast('const GSERIALIZED *', geom) - radius_converted = _ffi.cast('double *', radius) +def geom_min_bounding_radius( + geom: Annotated[_ffi.CData, "const GSERIALIZED *"], radius: Annotated[_ffi.CData, "double *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + geom_converted = _ffi.cast("const GSERIALIZED *", geom) + radius_converted = _ffi.cast("double *", radius) result = _lib.geom_min_bounding_radius(geom_converted, radius_converted) _check_error() return result if result != _ffi.NULL else None -def geom_shortestline2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], s2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - s2_converted = _ffi.cast('const GSERIALIZED *', s2) +def geom_shortestline2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], s2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + s2_converted = _ffi.cast("const GSERIALIZED *", s2) result = _lib.geom_shortestline2d(gs1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_shortestline3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], s2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - s2_converted = _ffi.cast('const GSERIALIZED *', s2) +def geom_shortestline3d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], s2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + s2_converted = _ffi.cast("const GSERIALIZED *", s2) result = _lib.geom_shortestline3d(gs1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_unary_union(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], prec: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_unary_union( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], prec: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_unary_union(gs_converted, prec) _check_error() return result if result != _ffi.NULL else None -def line_interpolate_point(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], distance_fraction: float, repeat: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def line_interpolate_point( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], distance_fraction: float, repeat: bool +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.line_interpolate_point(gs_converted, distance_fraction, repeat) _check_error() return result if result != _ffi.NULL else None -def line_locate_point(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def line_locate_point( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.line_locate_point(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def line_substring(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], from_: float, to: float) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def line_substring( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], from_: float, to: float +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.line_substring(gs_converted, from_, to) _check_error() return result if result != _ffi.NULL else None -def geog_dwithin(g1: Annotated[_ffi.CData, 'const GSERIALIZED *'], g2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float, use_spheroid: bool) -> Annotated[bool, 'bool']: - g1_converted = _ffi.cast('const GSERIALIZED *', g1) - g2_converted = _ffi.cast('const GSERIALIZED *', g2) +def geog_dwithin( + g1: Annotated[_ffi.CData, "const GSERIALIZED *"], + g2: Annotated[_ffi.CData, "const GSERIALIZED *"], + tolerance: float, + use_spheroid: bool, +) -> Annotated[bool, "bool"]: + g1_converted = _ffi.cast("const GSERIALIZED *", g1) + g2_converted = _ffi.cast("const GSERIALIZED *", g2) result = _lib.geog_dwithin(g1_converted, g2_converted, tolerance, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geog_intersects(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], use_spheroid: bool) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geog_intersects( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], + gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], + use_spheroid: bool, +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geog_intersects(gs1_converted, gs2_converted, use_spheroid) _check_error() return result if result != _ffi.NULL else None -def geom_contains(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_contains( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_contains(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_covers(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_covers( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_covers(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_disjoint2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_disjoint2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_disjoint2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_dwithin2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_dwithin2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], + gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], + tolerance: float, +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_dwithin2d(gs1_converted, gs2_converted, tolerance) _check_error() return result if result != _ffi.NULL else None -def geom_dwithin3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], tolerance: float) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_dwithin3d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], + gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], + tolerance: float, +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_dwithin3d(gs1_converted, gs2_converted, tolerance) _check_error() return result if result != _ffi.NULL else None -def geom_intersects2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_intersects2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_intersects2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_intersects3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_intersects3d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_intersects3d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_relate_pattern(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *'], patt: str) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) - patt_converted = patt.encode('utf-8') +def geom_relate_pattern( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"], patt: str +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) + patt_converted = patt.encode("utf-8") result = _lib.geom_relate_pattern(gs1_converted, gs2_converted, patt_converted) _check_error() return result if result != _ffi.NULL else None -def geom_touches(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_touches( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "bool"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_touches(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - count = _ffi.new('int *') +def geo_stboxes( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + count = _ffi.new("int *") result = _lib.geo_stboxes(gs_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geo_split_each_n_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - count = _ffi.new('int *') +def geo_split_each_n_stboxes( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], elem_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + count = _ffi.new("int *") result = _lib.geo_split_each_n_stboxes(gs_converted, elem_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geo_split_n_stboxes(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - count = _ffi.new('int *') +def geo_split_n_stboxes( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], box_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + count = _ffi.new("int *") result = _lib.geo_split_n_stboxes(gs_converted, box_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geog_distance(g1: Annotated[_ffi.CData, 'const GSERIALIZED *'], g2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - g1_converted = _ffi.cast('const GSERIALIZED *', g1) - g2_converted = _ffi.cast('const GSERIALIZED *', g2) +def geog_distance( + g1: Annotated[_ffi.CData, "const GSERIALIZED *"], g2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + g1_converted = _ffi.cast("const GSERIALIZED *", g1) + g2_converted = _ffi.cast("const GSERIALIZED *", g2) result = _lib.geog_distance(g1_converted, g2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_distance2d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_distance2d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_distance2d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geom_distance3d(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geom_distance3d( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geom_distance3d(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_equals(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geo_equals( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) result = _lib.geo_equals(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_same(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[bool, 'bool']: - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) +def geo_same( + gs1: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def geogset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def geogset_in(string: str) -> Annotated[_ffi.CData, "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) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def geomset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: + string_converted = string.encode("utf-8") result = _lib.geomset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_as_text(set: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def spatialset_as_text(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: + set_converted = _ffi.cast("const Set *", set) result = _lib.spatialset_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 spatialset_as_ewkt(set: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: - set_converted = _ffi.cast('const Set *', set) +def spatialset_as_ewkt(set: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: + set_converted = _ffi.cast("const Set *", set) result = _lib.spatialset_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_make(values: Annotated[list, 'GSERIALIZED **']) -> Annotated[_ffi.CData, 'Set *']: - values_converted = [_ffi.cast('GSERIALIZED *', x) for x in values] +def geoset_make(values: Annotated[list, "GSERIALIZED **"]) -> Annotated[_ffi.CData, "Set *"]: + values_converted = [_ffi.cast("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 geo_to_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_to_set(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Set *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_to_set(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - s_converted = _ffi.cast('const Set *', s) +def geoset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - s_converted = _ffi.cast('const Set *', s) +def geoset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, 'GSERIALIZED **']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('GSERIALIZED **') +def geoset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "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: @@ -11108,326 +12225,370 @@ def geoset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated return None -def geoset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'GSERIALIZED **']: - s_converted = _ffi.cast('const Set *', s) +def geoset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 contained_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def contained_geo_set( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "bool"]: + gs_converted = _ffi.cast("const 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 contains_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def contains_set_geo( + s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] +) -> Annotated[bool, "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 geo_union_transfn(state: Annotated[_ffi.CData, 'Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_union_transfn( + state: Annotated[_ffi.CData, "Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Set *"]: + state_converted = _ffi.cast("Set *", state) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geo_union_transfn(state_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def intersection_geo_set( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 intersection_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def intersection_set_geo( + s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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 minus_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def minus_geo_set( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def minus_set_geo( + s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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 union_geo_set(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def union_geo_set( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 union_set_geo(s: Annotated[_ffi.CData, 'const Set *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def union_set_geo( + s: Annotated[_ffi.CData, "const Set *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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 spatialset_set_srid(s: Annotated[_ffi.CData, 'const Set *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - srid_converted = _ffi.cast('int32_t', srid) +def spatialset_set_srid( + s: Annotated[_ffi.CData, "const Set *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.spatialset_set_srid(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_srid(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'int32_t']: - s_converted = _ffi.cast('const Set *', s) +def spatialset_srid(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "int32_t"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.spatialset_srid(s_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_transform(s: Annotated[_ffi.CData, 'const Set *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - srid_converted = _ffi.cast('int32_t', srid) +def spatialset_transform( + s: Annotated[_ffi.CData, "const Set *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.spatialset_transform(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_transform_pipeline(s: Annotated[_ffi.CData, 'const Set *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - pipelinestr_converted = pipelinestr.encode('utf-8') - srid_converted = _ffi.cast('int32_t', srid) +def spatialset_transform_pipeline( + s: Annotated[_ffi.CData, "const Set *"], pipelinestr: str, srid: Annotated[_ffi.CData, "int32_t"], is_forward: bool +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32_t", srid) result = _lib.spatialset_transform_pipeline(s_converted, pipelinestr_converted, srid_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def stbox_as_hexwkb(box: Annotated[_ffi.CData, 'const STBox *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "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_as_wkb(box: Annotated[_ffi.CData, 'const STBox *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: - 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: Annotated[_ffi.CData, "const STBox *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: + 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 return result_converted -def stbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'STBox *']: - hexwkb_converted = hexwkb.encode('utf-8') +def stbox_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "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 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_in(string: str) -> Annotated[_ffi.CData, 'STBox *']: - string_converted = string.encode('utf-8') +def stbox_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *'], maxdd: int) -> Annotated[str, 'char *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_out(box: Annotated[_ffi.CData, "const STBox *"], maxdd: int) -> Annotated[str, "char *"]: + 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 geo_timestamptz_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, 'STBox *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - t_converted = _ffi.cast('TimestampTz', t) +def geo_timestamptz_to_stbox( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int +) -> Annotated[_ffi.CData, "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 geo_tstzspan_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'STBox *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Span *', s) +def geo_tstzspan_to_stbox( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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_copy(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_copy(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'] | None) -> Annotated[_ffi.CData, 'STBox *']: - srid_converted = _ffi.cast('int32', srid) - s_converted = _ffi.cast('const Span *', s) if s is not None else _ffi.NULL +def stbox_make( + hasx: bool, + hasz: bool, + geodetic: bool, + srid: int, + xmin: float, + xmax: float, + ymin: float, + ymax: float, + zmin: float, + zmax: float, + s: Annotated[_ffi.CData, "const Span *"] | None, +) -> Annotated[_ffi.CData, "STBox *"]: + srid_converted = _ffi.cast("int32", srid) + s_converted = _ffi.cast("const Span *", s) if s is not None else _ffi.NULL 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 geo_to_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'STBox *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geo_to_stbox(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "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 spatialset_to_stbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'STBox *']: - s_converted = _ffi.cast('const Set *', s) +def spatialset_to_stbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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_box3d(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'BOX3D *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_to_box3d(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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_gbox(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'GBOX *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_to_gbox(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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_geo(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_to_geo(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'Span *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_to_tstzspan(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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 timestamptz_to_stbox(t: int) -> Annotated[_ffi.CData, 'STBox *']: - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_stbox(t: int) -> Annotated[_ffi.CData, "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 tstzset_to_stbox(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'STBox *']: - s_converted = _ffi.cast('const Set *', s) +def tstzset_to_stbox(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'STBox *']: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_to_stbox(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'STBox *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_to_stbox(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 stbox_area(box: Annotated[_ffi.CData, 'const STBox *'], spheroid: bool) -> Annotated[float, 'double']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_area(box: Annotated[_ffi.CData, "const STBox *"], spheroid: bool) -> Annotated[float, "double"]: + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_area(box_converted, spheroid) _check_error() return result if result != _ffi.NULL else None -def stbox_hash(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[int, 'uint32']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_hash(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[int, "uint32"]: + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_hash(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hash_extended(box: Annotated[_ffi.CData, 'const STBox *'], seed: int) -> Annotated[int, 'uint64']: - box_converted = _ffi.cast('const STBox *', box) - seed_converted = _ffi.cast('uint64', seed) +def stbox_hash_extended(box: Annotated[_ffi.CData, "const STBox *"], seed: int) -> Annotated[int, "uint64"]: + box_converted = _ffi.cast("const STBox *", box) + seed_converted = _ffi.cast("uint64", seed) result = _lib.stbox_hash_extended(box_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hast(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_hast(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_hasx(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_hasz(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_isgeodetic(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[bool, "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_perimeter(box: Annotated[_ffi.CData, 'const STBox *'], spheroid: bool) -> Annotated[float, 'double']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_perimeter(box: Annotated[_ffi.CData, "const STBox *"], spheroid: bool) -> Annotated[float, "double"]: + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_perimeter(box_converted, spheroid) _check_error() return result if result != _ffi.NULL else None -def stbox_tmax(box: Annotated[_ffi.CData, 'const STBox *']) -> int: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('TimestampTz *') +def stbox_tmax(box: Annotated[_ffi.CData, "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: @@ -11435,9 +12596,9 @@ def stbox_tmax(box: Annotated[_ffi.CData, 'const STBox *']) -> int: return None -def stbox_tmax_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('bool *') +def stbox_tmax_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11445,9 +12606,9 @@ def stbox_tmax_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ff return None -def stbox_tmin(box: Annotated[_ffi.CData, 'const STBox *']) -> int: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('TimestampTz *') +def stbox_tmin(box: Annotated[_ffi.CData, "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: @@ -11455,9 +12616,9 @@ def stbox_tmin(box: Annotated[_ffi.CData, 'const STBox *']) -> int: return None -def stbox_tmin_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('bool *') +def stbox_tmin_inc(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11465,16 +12626,16 @@ def stbox_tmin_inc(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ff return None -def stbox_volume(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_volume(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[float, "double"]: + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_volume(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_xmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_xmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11482,9 +12643,9 @@ def stbox_xmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_xmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_xmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11492,9 +12653,9 @@ def stbox_xmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_ymax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_ymax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11502,9 +12663,9 @@ def stbox_ymax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_ymin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_ymin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11512,9 +12673,9 @@ def stbox_ymin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_zmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_zmax(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11522,9 +12683,9 @@ def stbox_zmax(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_zmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'double']: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_zmin(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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: @@ -11532,582 +12693,730 @@ def stbox_zmin(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CD return None -def stbox_expand_space(box: Annotated[_ffi.CData, 'const STBox *'], d: float) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_expand_space(box: Annotated[_ffi.CData, "const STBox *"], d: float) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) - interv_converted = _ffi.cast('const Interval *', interv) +def stbox_expand_time( + box: Annotated[_ffi.CData, "const STBox *"], interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_get_space(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "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_quad_split(box: Annotated[_ffi.CData, 'const STBox *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - box_converted = _ffi.cast('const STBox *', box) - count = _ffi.new('int *') +def stbox_quad_split( + box: Annotated[_ffi.CData, "const STBox *"], +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const STBox *'], maxdd: int) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_round(box: Annotated[_ffi.CData, "const STBox *"], maxdd: int) -> Annotated[_ffi.CData, "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_shift_scale_time(box: Annotated[_ffi.CData, 'const STBox *'], shift: Annotated[_ffi.CData, 'const Interval *'] | None, duration: Annotated[_ffi.CData, 'const Interval *'] | None) -> Annotated[_ffi.CData, '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 +def stbox_shift_scale_time( + box: Annotated[_ffi.CData, "const STBox *"], + shift: Annotated[_ffi.CData, "const Interval *"] | None, + duration: Annotated[_ffi.CData, "const Interval *"] | None, +) -> Annotated[_ffi.CData, "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 stboxarr_round(boxarr: Annotated[_ffi.CData, 'const STBox *'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'STBox *']: - boxarr_converted = _ffi.cast('const STBox *', boxarr) +def stboxarr_round( + boxarr: Annotated[_ffi.CData, "const STBox *"], count: int, maxdd: int +) -> Annotated[_ffi.CData, "STBox *"]: + boxarr_converted = _ffi.cast("const STBox *", boxarr) result = _lib.stboxarr_round(boxarr_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def stbox_set_srid(box: Annotated[_ffi.CData, 'const STBox *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) - srid_converted = _ffi.cast('int32_t', srid) +def stbox_set_srid( + box: Annotated[_ffi.CData, "const STBox *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "STBox *"]: + box_converted = _ffi.cast("const STBox *", box) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.stbox_set_srid(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_srid(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'int32_t']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_srid(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "int32_t"]: + 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_transform(box: Annotated[_ffi.CData, 'const STBox *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) - srid_converted = _ffi.cast('int32_t', srid) +def stbox_transform( + box: Annotated[_ffi.CData, "const STBox *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "STBox *"]: + box_converted = _ffi.cast("const STBox *", box) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.stbox_transform(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_transform_pipeline(box: Annotated[_ffi.CData, 'const STBox *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const STBox *', box) - pipelinestr_converted = pipelinestr.encode('utf-8') - srid_converted = _ffi.cast('int32_t', srid) +def stbox_transform_pipeline( + box: Annotated[_ffi.CData, "const STBox *"], + pipelinestr: str, + srid: Annotated[_ffi.CData, "int32_t"], + is_forward: bool, +) -> Annotated[_ffi.CData, "STBox *"]: + box_converted = _ffi.cast("const STBox *", box) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32_t", 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 adjacent_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def adjacent_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def contained_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 contains_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def contains_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overlaps_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overlaps_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def same_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 above_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def above_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 after_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def after_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 back_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def back_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 before_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def before_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 below_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def below_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 front_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def front_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 left_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def left_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overabove_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overabove_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overafter_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overafter_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overback_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overback_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overbefore_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overbefore_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overbelow_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overbelow_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overfront_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overfront_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overleft_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overleft_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 overright_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overright_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 right_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def right_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 union_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *'], strict: bool) -> Annotated[_ffi.CData, 'STBox *']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def union_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"], strict: bool +) -> Annotated[_ffi.CData, "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 intersection_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'STBox *']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def intersection_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[_ffi.CData, "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 stbox_cmp(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[int, 'int']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_cmp( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[int, "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_eq(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_eq( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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_ge(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_ge( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_gt( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 stbox_le(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_le( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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_lt(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_lt( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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_ne(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_ne( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "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 tgeogpoint_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeogpoint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeogpoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeogpoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeogpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_from_mfjson(mfjson: str) -> Annotated[_ffi.CData, 'Temporal *']: - mfjson_converted = mfjson.encode('utf-8') +def tgeography_from_mfjson(mfjson: str) -> Annotated[_ffi.CData, "Temporal *"]: + mfjson_converted = mfjson.encode("utf-8") result = _lib.tgeography_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeography_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeography_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeometry_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeometry_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeometry_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeometry_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_from_mfjson(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeompoint_from_mfjson(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeompoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tgeompoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tgeompoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_as_ewkt(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_as_ewkt(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_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 tspatial_as_text(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_as_text(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_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 tspatial_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_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 tgeo_from_base_temp(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_from_base_temp( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_from_base_temp(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_make(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - t_converted = _ffi.cast('TimestampTz', t) +def tgeoinst_make(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int) -> Annotated[_ffi.CData, "TInstant *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tgeoinst_make(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_from_base_tstzset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def tgeoseq_from_base_tstzset( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "TSequence *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) result = _lib.tgeoseq_from_base_tstzset(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_from_base_tstzspan(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Span *', s) +def tgeoseq_from_base_tstzspan( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + s: Annotated[_ffi.CData, "const Span *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequence *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Span *", s) result = _lib.tgeoseq_from_base_tstzspan(gs_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_from_base_tstzspanset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tgeoseqset_from_base_tstzspanset( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + ss: Annotated[_ffi.CData, "const SpanSet *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tgeoseqset_from_base_tstzspanset(gs_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tpoint_from_base_temp(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_from_base_temp( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - t_converted = _ffi.cast('TimestampTz', t) +def tpointinst_make(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], t: int) -> Annotated[_ffi.CData, "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_tstzset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def tpointseq_from_base_tstzset( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 tpointseq_from_base_tstzspan(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Span *', s) +def tpointseq_from_base_tstzspan( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + s: Annotated[_ffi.CData, "const Span *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequence *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Span *", s) result = _lib.tpointseq_from_base_tstzspan(gs_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_coords(xcoords: Annotated[_ffi.CData, 'const double *'], ycoords: Annotated[_ffi.CData, 'const double *'], zcoords: Annotated[_ffi.CData, 'const double *'], times: int, count: int, srid: int, geodetic: bool, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, '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) - result = _lib.tpointseq_make_coords(xcoords_converted, ycoords_converted, zcoords_converted, times_converted, count, srid_converted, geodetic, lower_inc, upper_inc, interp, normalize) +def tpointseq_make_coords( + xcoords: Annotated[_ffi.CData, "const double *"], + ycoords: Annotated[_ffi.CData, "const double *"], + zcoords: Annotated[_ffi.CData, "const double *"], + times: int, + count: int, + srid: int, + geodetic: bool, + lower_inc: bool, + upper_inc: bool, + interp: InterpolationType, + normalize: bool, +) -> Annotated[_ffi.CData, "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) + result = _lib.tpointseq_make_coords( + xcoords_converted, + ycoords_converted, + zcoords_converted, + times_converted, + count, + srid_converted, + geodetic, + lower_inc, + upper_inc, + interp, + normalize, + ) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_from_base_tstzspanset(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tpointseqset_from_base_tstzspanset( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + ss: Annotated[_ffi.CData, "const SpanSet *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tpointseqset_from_base_tstzspanset(gs_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def box3d_to_stbox(box: Annotated[_ffi.CData, 'const BOX3D *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const BOX3D *', box) +def box3d_to_stbox(box: Annotated[_ffi.CData, "const BOX3D *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const GBOX *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const GBOX *', box) +def gbox_to_stbox(box: Annotated[_ffi.CData, "const GBOX *"]) -> Annotated[_ffi.CData, "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 geomeas_to_tpoint(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geomeas_to_tpoint(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "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_tgeography(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeogpoint_to_tgeography(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeogpoint_to_tgeography(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_to_tgeogpoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeography_to_tgeogpoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeography_to_tgeogpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeography_to_tgeometry(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeography_to_tgeometry(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeography_to_tgeometry(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_to_tgeography(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeometry_to_tgeography(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeometry_to_tgeography(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometry_to_tgeompoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeometry_to_tgeompoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeometry_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tgeometry(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeompoint_to_tgeometry(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeompoint_to_tgeometry(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_as_mvtgeom(temp: Annotated[_ffi.CData, 'const Temporal *'], bounds: Annotated[_ffi.CData, 'const STBox *'], extent: Annotated[_ffi.CData, 'int32_t'], buffer: Annotated[_ffi.CData, 'int32_t'], clip_geom: bool, gsarr: Annotated[list, 'GSERIALIZED **'], timesarr: Annotated[list, 'int64 **']) -> tuple[Annotated[bool, 'bool'], Annotated[_ffi.CData, '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_as_mvtgeom(temp_converted, bounds_converted, extent_converted, buffer_converted, clip_geom, gsarr_converted, timesarr_converted, count) +def tpoint_as_mvtgeom( + temp: Annotated[_ffi.CData, "const Temporal *"], + bounds: Annotated[_ffi.CData, "const STBox *"], + extent: Annotated[_ffi.CData, "int32_t"], + buffer: Annotated[_ffi.CData, "int32_t"], + clip_geom: bool, + gsarr: Annotated[list, "GSERIALIZED **"], + timesarr: Annotated[list, "int64 **"], +) -> tuple[Annotated[bool, "bool"], Annotated[_ffi.CData, "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_as_mvtgeom( + 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_tfloat_to_geomeas(tpoint: Annotated[_ffi.CData, 'const Temporal *'], measure: Annotated[_ffi.CData, 'const Temporal *'], segmentize: bool) -> Annotated[list, 'GSERIALIZED **']: - tpoint_converted = _ffi.cast('const Temporal *', tpoint) - measure_converted = _ffi.cast('const Temporal *', measure) - out_result = _ffi.new('GSERIALIZED **') +def tpoint_tfloat_to_geomeas( + tpoint: Annotated[_ffi.CData, "const Temporal *"], + measure: Annotated[_ffi.CData, "const Temporal *"], + segmentize: bool, +) -> Annotated[list, "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: @@ -12115,17 +13424,19 @@ def tpoint_tfloat_to_geomeas(tpoint: Annotated[_ffi.CData, 'const Temporal *'], return None -def tspatial_to_stbox(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'STBox *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_to_stbox(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "STBox *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_to_stbox(temp_converted) _check_error() return result if result != _ffi.NULL else None -def bearing_point_point(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const GSERIALIZED *"], gs2: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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: @@ -12133,61 +13444,69 @@ def bearing_point_point(gs1: Annotated[_ffi.CData, 'const GSERIALIZED *'], gs2: return None -def bearing_tpoint_point(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], invert: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def bearing_tpoint_point( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], invert: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def bearing_tpoint_tpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "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 tgeo_centroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_centroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_centroid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_convex_hull(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_convex_hull(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_convex_hull(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_traversed_area(temp: Annotated[_ffi.CData, 'const Temporal *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_traversed_area( + temp: Annotated[_ffi.CData, "const Temporal *"], unary_union: bool +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_traversed_area(temp_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tgeo_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[list, 'GSERIALIZED **']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('GSERIALIZED **') +def tgeo_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[list, "GSERIALIZED **"]: + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("GSERIALIZED **") result = _lib.tgeo_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: @@ -12195,9 +13514,9 @@ def tgeo_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t return None -def tgeo_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[list, 'GSERIALIZED **']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('GSERIALIZED **') +def tgeo_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[list, "GSERIALIZED **"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("GSERIALIZED **") result = _lib.tgeo_value_n(temp_converted, n, out_result) _check_error() if result: @@ -12205,38 +13524,40 @@ def tgeo_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Ann return None -def tgeo_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tgeo_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "GSERIALIZED **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tgeo_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpoint_angular_difference(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_angular_difference(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_azimuth(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_cumulative_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_cumulative_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('double *') +def tpoint_direction(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: @@ -12244,1747 +13565,2304 @@ def tpoint_direction(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotat return None -def tpoint_get_x(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_get_x(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_get_y(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_get_z(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_is_simple(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_speed(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_trajectory(temp: Annotated[_ffi.CData, 'const Temporal *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_trajectory( + temp: Annotated[_ffi.CData, "const Temporal *"], unary_union: bool +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_trajectory(temp_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tpoint_twcentroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_twcentroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 tgeo_affine(temp: Annotated[_ffi.CData, 'const Temporal *'], a: Annotated[_ffi.CData, 'const AFFINE *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - a_converted = _ffi.cast('const AFFINE *', a) +def tgeo_affine( + temp: Annotated[_ffi.CData, "const Temporal *"], a: Annotated[_ffi.CData, "const AFFINE *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + a_converted = _ffi.cast("const AFFINE *", a) result = _lib.tgeo_affine(temp_converted, a_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_scale(temp: Annotated[_ffi.CData, 'const Temporal *'], scale: Annotated[_ffi.CData, 'const GSERIALIZED *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - scale_converted = _ffi.cast('const GSERIALIZED *', scale) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) +def tgeo_scale( + temp: Annotated[_ffi.CData, "const Temporal *"], + scale: Annotated[_ffi.CData, "const GSERIALIZED *"], + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + scale_converted = _ffi.cast("const GSERIALIZED *", scale) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) result = _lib.tgeo_scale(temp_converted, scale_converted, sorigin_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_make_simple(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tpoint_make_simple( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[_ffi.CData, "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 tspatial_srid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'int32_t']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_srid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "int32_t"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_srid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_set_srid(temp: Annotated[_ffi.CData, 'const Temporal *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - srid_converted = _ffi.cast('int32_t', srid) +def tspatial_set_srid( + temp: Annotated[_ffi.CData, "const Temporal *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.tspatial_set_srid(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_transform(temp: Annotated[_ffi.CData, 'const Temporal *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - srid_converted = _ffi.cast('int32_t', srid) +def tspatial_transform( + temp: Annotated[_ffi.CData, "const Temporal *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.tspatial_transform(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_transform_pipeline(temp: Annotated[_ffi.CData, 'const Temporal *'], pipelinestr: str, srid: Annotated[_ffi.CData, 'int32_t'], is_forward: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - pipelinestr_converted = pipelinestr.encode('utf-8') - srid_converted = _ffi.cast('int32_t', srid) +def tspatial_transform_pipeline( + temp: Annotated[_ffi.CData, "const Temporal *"], + pipelinestr: str, + srid: Annotated[_ffi.CData, "int32_t"], + is_forward: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32_t", srid) result = _lib.tspatial_transform_pipeline(temp_converted, pipelinestr_converted, srid_converted, is_forward) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tgeo_at_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tgeo_at_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tgeo_at_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeo_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tgeo_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tgeo_at_value( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("GSERIALIZED *", gs) result = _lib.tgeo_at_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tgeo_minus_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tgeo_minus_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tgeo_minus_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeo_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tgeo_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tgeo_minus_value( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("GSERIALIZED *", gs) result = _lib.tgeo_minus_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tpoint_at_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tpoint_at_geom(temp_converted, gs_converted, zspan_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tpoint_at_value( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tpoint_minus_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tpoint_minus_geom(temp_converted, gs_converted, zspan_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_value(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tpoint_minus_value( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "GSERIALIZED *"] +) -> Annotated[_ffi.CData, "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 always_eq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.always_eq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def always_eq_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.always_eq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_eq_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.always_eq_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.always_ne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def always_ne_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.always_ne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_ne_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.always_ne_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ever_eq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def ever_eq_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.ever_eq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_eq_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ever_eq_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ever_ne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def ever_ne_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.ever_ne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_ne_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ever_ne_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def teq_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.teq_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def teq_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.teq_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tne_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tne_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tne_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tne_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tne_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tgeo_stboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tgeo_stboxes(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeo_space_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - count = _ffi.new('int *') +def tgeo_space_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], + xsize: float, + ysize: float, + zsize: float, + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + bitmatrix: bool, + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + count = _ffi.new("int *") result = _lib.tgeo_space_boxes(temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeo_space_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') - result = _lib.tgeo_space_time_boxes(temp_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, bitmatrix, border_inc, count) +def tgeo_space_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], + xsize: float, + ysize: float, + zsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + torigin: int, + bitmatrix: bool, + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") + result = _lib.tgeo_space_time_boxes( + temp_converted, + xsize, + ysize, + zsize, + duration_converted, + sorigin_converted, + torigin_converted, + bitmatrix, + border_inc, + count, + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeo_split_each_n_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], elem_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tgeo_split_each_n_stboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], elem_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tgeo_split_each_n_stboxes(temp_converted, elem_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeo_split_n_stboxes(temp: Annotated[_ffi.CData, 'const Temporal *'], box_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tgeo_split_n_stboxes( + temp: Annotated[_ffi.CData, "const Temporal *"], box_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tgeo_split_n_stboxes(temp_converted, box_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def adjacent_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def adjacent_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.adjacent_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def adjacent_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.adjacent_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def adjacent_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.adjacent_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def contained_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.contained_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def contained_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.contained_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contained_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.contained_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def contains_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.contains_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def contains_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.contains_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def contains_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.contains_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overlaps_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overlaps_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overlaps_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overlaps_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overlaps_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overlaps_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def same_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.same_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def same_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.same_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def same_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def same_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.same_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def above_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.above_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def above_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.above_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def above_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def above_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.above_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def after_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.after_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def after_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.after_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def after_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def after_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.after_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def back_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.back_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def back_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.back_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def back_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def back_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.back_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def before_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.before_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def before_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.before_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def before_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def before_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.before_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def below_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def below_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.below_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def below_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def below_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.below_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def below_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def below_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.below_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def front_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def front_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.front_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def front_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def front_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.front_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def front_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def front_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.front_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def left_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def left_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.left_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def left_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.left_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def left_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def left_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.left_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overabove_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overabove_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overabove_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overabove_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overabove_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overabove_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overafter_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overafter_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overafter_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overafter_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overafter_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overafter_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overback_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overback_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overback_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overback_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overback_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overback_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overbefore_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overbefore_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overbefore_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overbefore_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overbefore_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overbefore_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overbelow_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overbelow_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overbelow_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overbelow_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overbelow_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overbelow_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overfront_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overfront_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overfront_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overfront_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overfront_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overfront_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overleft_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overleft_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overleft_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overleft_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overleft_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overleft_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def overright_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.overright_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def overright_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.overright_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def overright_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.overright_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_tspatial(box: Annotated[_ffi.CData, 'const STBox *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) +def right_stbox_tspatial( + box: Annotated[_ffi.CData, "const STBox *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.right_stbox_tspatial(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tspatial_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def right_tspatial_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[bool, "bool"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.right_tspatial_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_tspatial_tspatial(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[bool, 'bool']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def right_tspatial_tspatial( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[bool, "bool"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.right_tspatial_tspatial(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def acontains_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.acontains_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def acontains_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.acontains_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def acontains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def acontains_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.acontains_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def adisjoint_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.adisjoint_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def adisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def adisjoint_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.adisjoint_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def adwithin_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], dist: float +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.adwithin_tgeo_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def adwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def adwithin_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], dist: float +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.adwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def aintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def aintersects_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.aintersects_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def aintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def aintersects_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.aintersects_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def atouches_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.atouches_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def atouches_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.atouches_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def atouches_tpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def atouches_tpoint_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "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 econtains_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def econtains_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.econtains_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def econtains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def econtains_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.econtains_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def econtains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def econtains_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.econtains_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def ecovers_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ecovers_geo_tgeo(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def ecovers_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.ecovers_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ecovers_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ecovers_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ecovers_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def edisjoint_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.edisjoint_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def edisjoint_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.edisjoint_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def edwithin_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"], dist: float +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.edwithin_tgeo_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def edwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def edwithin_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"], dist: float +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.edwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def eintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def eintersects_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.eintersects_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def eintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def eintersects_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.eintersects_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def etouches_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.etouches_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def etouches_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.etouches_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def etouches_tpoint_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[int, "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_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tcontains_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tcontains_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcontains_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tcontains_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tcontains_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcontains_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tcontains_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tcontains_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tcovers_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tcovers_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tcovers_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tcovers_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tcovers_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tcovers_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tcovers_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tdisjoint_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tdisjoint_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tdisjoint_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tdisjoint_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tdisjoint_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tdisjoint_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tdwithin_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + dist: float, + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tdwithin_geo_tgeo(gs_converted, temp_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tdwithin_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + dist: float, + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tdwithin_tgeo_geo(temp_converted, gs_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], dist: float, restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tdwithin_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + dist: float, + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tdwithin_tgeo_tgeo(temp1_converted, temp2_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tintersects_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tintersects_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tintersects_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tintersects_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tintersects_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tintersects_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_geo_tgeo(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], temp: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def ttouches_geo_tgeo( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + temp: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttouches_geo_tgeo(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def ttouches_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.ttouches_tgeo_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *'], restr: bool, atvalue: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ttouches_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], + temp2: Annotated[_ffi.CData, "const Temporal *"], + restr: bool, + atvalue: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ttouches_tgeo_tgeo(temp1_converted, temp2_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdistance_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tdistance_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tdistance_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tdistance_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tdistance_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_geo(box: Annotated[_ffi.CData, 'const STBox *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - box_converted = _ffi.cast('const STBox *', box) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def nad_stbox_geo( + box: Annotated[_ffi.CData, "const STBox *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "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: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def nad_stbox_stbox( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[float, "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_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def nad_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.nad_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tgeo_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def nad_tgeo_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.nad_tgeo_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nad_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "double"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.nad_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def nai_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.nai_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nai_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "TInstant *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.nai_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tgeo_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def shortestline_tgeo_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.shortestline_tgeo_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tgeo_tgeo(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def shortestline_tgeo_tgeo( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.shortestline_tgeo_tgeo(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_finalfn(state: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, 'Temporal *']: - state_converted = _ffi.cast('SkipList *', state) +def tpoint_tcentroid_finalfn(state: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'Temporal *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('Temporal *', temp) +def tpoint_tcentroid_transfn( + state: Annotated[_ffi.CData, "SkipList *"], temp: Annotated[_ffi.CData, "Temporal *"] +) -> Annotated[_ffi.CData, "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 tspatial_extent_transfn(box: Annotated[_ffi.CData, 'STBox *'] | None, temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('STBox *', box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) +def tspatial_extent_transfn( + box: Annotated[_ffi.CData, "STBox *"] | None, temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "STBox *"]: + box_converted = _ffi.cast("STBox *", box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tspatial_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space_tile(point: Annotated[_ffi.CData, 'const GSERIALIZED *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'STBox *']: - point_converted = _ffi.cast('const GSERIALIZED *', point) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) +def stbox_get_space_tile( + point: Annotated[_ffi.CData, "const GSERIALIZED *"], + xsize: float, + ysize: float, + zsize: float, + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], +) -> Annotated[_ffi.CData, "STBox *"]: + point_converted = _ffi.cast("const GSERIALIZED *", point) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) result = _lib.stbox_get_space_tile(point_converted, xsize, ysize, zsize, sorigin_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space_time_tile(point: Annotated[_ffi.CData, 'const GSERIALIZED *'], t: int, xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int) -> Annotated[_ffi.CData, 'STBox *']: - point_converted = _ffi.cast('const GSERIALIZED *', point) - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('const Interval *', duration) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - result = _lib.stbox_get_space_time_tile(point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted) +def stbox_get_space_time_tile( + point: Annotated[_ffi.CData, "const GSERIALIZED *"], + t: int, + xsize: float, + ysize: float, + zsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + torigin: int, +) -> Annotated[_ffi.CData, "STBox *"]: + point_converted = _ffi.cast("const GSERIALIZED *", point) + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("const Interval *", duration) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.stbox_get_space_time_tile( + point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted + ) _check_error() return result if result != _ffi.NULL else None -def stbox_get_time_tile(t: int, duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int) -> Annotated[_ffi.CData, 'STBox *']: - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) +def stbox_get_time_tile( + t: int, duration: Annotated[_ffi.CData, "const Interval *"], torigin: int +) -> Annotated[_ffi.CData, "STBox *"]: + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) result = _lib.stbox_get_time_tile(t_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_space_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - bounds_converted = _ffi.cast('const STBox *', bounds) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - count = _ffi.new('int *') +def stbox_space_tiles( + bounds: Annotated[_ffi.CData, "const STBox *"], + xsize: float, + ysize: float, + zsize: float, + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + bounds_converted = _ffi.cast("const STBox *", bounds) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + count = _ffi.new("int *") result = _lib.stbox_space_tiles(bounds_converted, xsize, ysize, zsize, sorigin_converted, border_inc, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def stbox_space_time_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'] | None, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, '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('const GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') - result = _lib.stbox_space_time_tiles(bounds_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, border_inc, count) +def stbox_space_time_tiles( + bounds: Annotated[_ffi.CData, "const STBox *"], + xsize: float, + ysize: float, + zsize: float, + duration: Annotated[_ffi.CData, "const Interval *"] | None, + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + torigin: int, + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "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("const GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") + result = _lib.stbox_space_time_tiles( + bounds_converted, + xsize, + ysize, + zsize, + duration_converted, + sorigin_converted, + torigin_converted, + border_inc, + count, + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def stbox_time_tiles(bounds: Annotated[_ffi.CData, 'const STBox *'], duration: Annotated[_ffi.CData, 'const Interval *'], torigin: int, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - bounds_converted = _ffi.cast('const STBox *', bounds) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') +def stbox_time_tiles( + bounds: Annotated[_ffi.CData, "const STBox *"], + duration: Annotated[_ffi.CData, "const Interval *"], + torigin: int, + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + bounds_converted = _ffi.cast("const STBox *", bounds) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") result = _lib.stbox_time_tiles(bounds_converted, duration_converted, torigin_converted, border_inc, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeo_space_split(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'GSERIALIZED ***'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - space_bins = _ffi.new('GSERIALIZED ***') - count = _ffi.new('int *') - result = _lib.tgeo_space_split(temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, space_bins, count) +def tgeo_space_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + xsize: float, + ysize: float, + zsize: float, + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + bitmatrix: bool, + border_inc: bool, +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[list, "GSERIALIZED ***"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + space_bins = _ffi.new("GSERIALIZED ***") + count = _ffi.new("int *") + result = _lib.tgeo_space_split( + temp_converted, xsize, ysize, zsize, sorigin_converted, bitmatrix, border_inc, space_bins, count + ) _check_error() return result if result != _ffi.NULL else None, space_bins[0], count[0] -def tgeo_space_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], xsize: float, ysize: float, zsize: float, duration: Annotated[_ffi.CData, 'const Interval *'], sorigin: Annotated[_ffi.CData, 'const GSERIALIZED *'], torigin: int, bitmatrix: bool, border_inc: bool) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[list, 'GSERIALIZED ***'], Annotated[list, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - sorigin_converted = _ffi.cast('const GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - space_bins = _ffi.new('GSERIALIZED ***') - time_bins = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tgeo_space_time_split(temp_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, bitmatrix, border_inc, space_bins, time_bins, count) +def tgeo_space_time_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + xsize: float, + ysize: float, + zsize: float, + duration: Annotated[_ffi.CData, "const Interval *"], + sorigin: Annotated[_ffi.CData, "const GSERIALIZED *"], + torigin: int, + bitmatrix: bool, + border_inc: bool, +) -> tuple[ + Annotated[_ffi.CData, "Temporal **"], + Annotated[list, "GSERIALIZED ***"], + Annotated[list, "TimestampTz *"], + Annotated[_ffi.CData, "int"], +]: + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + sorigin_converted = _ffi.cast("const GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + space_bins = _ffi.new("GSERIALIZED ***") + time_bins = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tgeo_space_time_split( + temp_converted, + xsize, + ysize, + zsize, + duration_converted, + sorigin_converted, + torigin_converted, + bitmatrix, + border_inc, + space_bins, + time_bins, + count, + ) _check_error() return result if result != _ffi.NULL else None, space_bins[0], time_bins[0], count[0] -def geo_cluster_kmeans(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], k: Annotated[_ffi.CData, 'uint32_t']) -> Annotated[_ffi.CData, 'int *']: - geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] - ngeoms_converted = _ffi.cast('uint32_t', ngeoms) - k_converted = _ffi.cast('uint32_t', k) +def geo_cluster_kmeans( + geoms: Annotated[list, "const GSERIALIZED **"], + ngeoms: Annotated[_ffi.CData, "uint32_t"], + k: Annotated[_ffi.CData, "uint32_t"], +) -> Annotated[_ffi.CData, "int *"]: + geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] + ngeoms_converted = _ffi.cast("uint32_t", ngeoms) + k_converted = _ffi.cast("uint32_t", k) result = _lib.geo_cluster_kmeans(geoms_converted, ngeoms_converted, k_converted) _check_error() return result if result != _ffi.NULL else None -def geo_cluster_dbscan(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], tolerance: float, minpoints: int) -> tuple[Annotated[_ffi.CData, 'uint32_t *'], Annotated[_ffi.CData, 'int']]: - geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] - ngeoms_converted = _ffi.cast('uint32_t', ngeoms) - count = _ffi.new('int *') +def geo_cluster_dbscan( + geoms: Annotated[list, "const GSERIALIZED **"], + ngeoms: Annotated[_ffi.CData, "uint32_t"], + tolerance: float, + minpoints: int, +) -> tuple[Annotated[_ffi.CData, "uint32_t *"], Annotated[_ffi.CData, "int"]]: + geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] + ngeoms_converted = _ffi.cast("uint32_t", ngeoms) + count = _ffi.new("int *") result = _lib.geo_cluster_dbscan(geoms_converted, ngeoms_converted, tolerance, minpoints, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geo_cluster_intersecting(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t']) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: - geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] - ngeoms_converted = _ffi.cast('uint32_t', ngeoms) - count = _ffi.new('int *') +def geo_cluster_intersecting( + geoms: Annotated[list, "const GSERIALIZED **"], ngeoms: Annotated[_ffi.CData, "uint32_t"] +) -> tuple[Annotated[_ffi.CData, "GSERIALIZED **"], Annotated[_ffi.CData, "int"]]: + geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] + ngeoms_converted = _ffi.cast("uint32_t", ngeoms) + count = _ffi.new("int *") result = _lib.geo_cluster_intersecting(geoms_converted, ngeoms_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def geo_cluster_within(geoms: Annotated[list, 'const GSERIALIZED **'], ngeoms: Annotated[_ffi.CData, 'uint32_t'], tolerance: float) -> tuple[Annotated[_ffi.CData, 'GSERIALIZED **'], Annotated[_ffi.CData, 'int']]: - geoms_converted = [_ffi.cast('const GSERIALIZED *', x) for x in geoms] - ngeoms_converted = _ffi.cast('uint32_t', ngeoms) - count = _ffi.new('int *') +def geo_cluster_within( + geoms: Annotated[list, "const GSERIALIZED **"], ngeoms: Annotated[_ffi.CData, "uint32_t"], tolerance: float +) -> tuple[Annotated[_ffi.CData, "GSERIALIZED **"], Annotated[_ffi.CData, "int"]]: + geoms_converted = [_ffi.cast("const GSERIALIZED *", x) for x in geoms] + ngeoms_converted = _ffi.cast("uint32_t", ngeoms) + count = _ffi.new("int *") result = _lib.geo_cluster_within(geoms_converted, ngeoms_converted, tolerance, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def gsl_get_generation_rng() -> Annotated[_ffi.CData, 'gsl_rng *']: +def gsl_get_generation_rng() -> Annotated[_ffi.CData, "gsl_rng *"]: result = _lib.gsl_get_generation_rng() _check_error() return result if result != _ffi.NULL else None -def gsl_get_aggregation_rng() -> Annotated[_ffi.CData, 'gsl_rng *']: +def gsl_get_aggregation_rng() -> Annotated[_ffi.CData, "gsl_rng *"]: result = _lib.gsl_get_aggregation_rng() _check_error() return result if result != _ffi.NULL else None -def datum_ceil(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - d_converted = _ffi.cast('Datum', d) +def datum_ceil(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: + d_converted = _ffi.cast("Datum", d) result = _lib.datum_ceil(d_converted) _check_error() return result if result != _ffi.NULL else None -def datum_degrees(d: Annotated[_ffi.CData, 'Datum'], normalize: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - d_converted = _ffi.cast('Datum', d) - normalize_converted = _ffi.cast('Datum', normalize) +def datum_degrees( + d: Annotated[_ffi.CData, "Datum"], normalize: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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_float_round(value: Annotated[_ffi.CData, 'Datum'], size: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - value_converted = _ffi.cast('Datum', value) - size_converted = _ffi.cast('Datum', size) +def datum_float_round( + value: Annotated[_ffi.CData, "Datum"], size: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Datum"]: + value_converted = _ffi.cast("Datum", value) + size_converted = _ffi.cast("Datum", size) result = _lib.datum_float_round(value_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def datum_floor(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - d_converted = _ffi.cast('Datum', d) +def datum_floor(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: + d_converted = _ffi.cast("Datum", d) result = _lib.datum_floor(d_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'uint32']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) +def datum_hash( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], seed: int) -> Annotated[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: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], seed: int +) -> Annotated[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 datum_radians(d: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - d_converted = _ffi.cast('Datum', d) +def datum_radians(d: Annotated[_ffi.CData, "Datum"]) -> Annotated[_ffi.CData, "Datum"]: + d_converted = _ffi.cast("Datum", d) result = _lib.datum_radians(d_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_round_set(s: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - out_result = _ffi.new('Span *') +def floatspan_round_set(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + out_result = _ffi.new("Span *") _lib.floatspan_round_set(s_converted, maxdd, 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 set_in(string: str, basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') - basetype_converted = _ffi.cast('meosType', basetype) +def set_in(string: str, basetype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Set *', s) +def set_out(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: + 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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Span *']: - string_converted = string.encode('utf-8') - spantype_converted = _ffi.cast('meosType', spantype) +def span_in(string: str, spantype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], maxdd: int) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Span *', s) +def span_out(s: Annotated[_ffi.CData, "const Span *"], maxdd: int) -> Annotated[str, "char *"]: + 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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'SpanSet *']: - string_converted = string.encode('utf-8') - spantype_converted = _ffi.cast('meosType', spantype) +def spanset_in(string: str, spantype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], maxdd: int) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_out(ss: Annotated[_ffi.CData, "const SpanSet *"], maxdd: int) -> Annotated[str, "char *"]: + 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_make(values: Annotated[_ffi.CData, 'const Datum *'], count: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.cast('const Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) +def set_make( + values: Annotated[_ffi.CData, "const Datum *"], count: int, basetype: Annotated[_ffi.CData, "meosType"], order: bool +) -> Annotated[_ffi.CData, "Set *"]: + values_converted = _ffi.cast("const Datum *", values) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.set_make(values_converted, count, basetype_converted, order) _check_error() return result if result != _ffi.NULL else None -def set_make_exp(values: Annotated[_ffi.CData, 'const Datum *'], count: int, maxcount: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.cast('const Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) +def set_make_exp( + values: Annotated[_ffi.CData, "const Datum *"], + count: int, + maxcount: int, + basetype: Annotated[_ffi.CData, "meosType"], + order: bool, +) -> Annotated[_ffi.CData, "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, order) _check_error() return result if result != _ffi.NULL else None -def set_make_free(values: Annotated[_ffi.CData, 'Datum *'], count: int, basetype: Annotated[_ffi.CData, 'meosType'], order: bool) -> Annotated[_ffi.CData, 'Set *']: - values_converted = _ffi.cast('Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) +def set_make_free( + values: Annotated[_ffi.CData, "Datum *"], count: int, basetype: Annotated[_ffi.CData, "meosType"], order: bool +) -> Annotated[_ffi.CData, "Set *"]: + values_converted = _ffi.cast("Datum *", values) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.set_make_free(values_converted, count, basetype_converted, order) _check_error() return result if result != _ffi.NULL else None -def span_make(lower: Annotated[_ffi.CData, 'Datum'], upper: Annotated[_ffi.CData, 'Datum'], lower_inc: bool, upper_inc: bool, basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Span *']: - lower_converted = _ffi.cast('Datum', lower) - upper_converted = _ffi.cast('Datum', upper) - basetype_converted = _ffi.cast('meosType', basetype) +def span_make( + lower: Annotated[_ffi.CData, "Datum"], + upper: Annotated[_ffi.CData, "Datum"], + lower_inc: bool, + upper_inc: bool, + basetype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[_ffi.CData, "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_set(lower: Annotated[_ffi.CData, 'Datum'], upper: Annotated[_ffi.CData, 'Datum'], lower_inc: bool, upper_inc: bool, basetype: Annotated[_ffi.CData, 'meosType'], spantype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - 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 span_set( + lower: Annotated[_ffi.CData, "Datum"], + upper: Annotated[_ffi.CData, "Datum"], + lower_inc: bool, + upper_inc: bool, + basetype: Annotated[_ffi.CData, "meosType"], + spantype: Annotated[_ffi.CData, "meosType"], + s: Annotated[_ffi.CData, "Span *"], +) -> Annotated[None, "void"]: + 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_make_exp(spans: Annotated[_ffi.CData, 'Span *'], count: int, maxcount: int, normalize: bool, order: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - spans_converted = _ffi.cast('Span *', spans) +def spanset_make_exp( + spans: Annotated[_ffi.CData, "Span *"], count: int, maxcount: int, normalize: bool, order: bool +) -> Annotated[_ffi.CData, "SpanSet *"]: + spans_converted = _ffi.cast("Span *", spans) result = _lib.spanset_make_exp(spans_converted, count, maxcount, normalize, order) _check_error() return result if result != _ffi.NULL else None -def spanset_make_free(spans: Annotated[_ffi.CData, 'Span *'], count: int, normalize: bool, order: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - spans_converted = _ffi.cast('Span *', spans) +def spanset_make_free( + spans: Annotated[_ffi.CData, "Span *"], count: int, normalize: bool, order: bool +) -> Annotated[_ffi.CData, "SpanSet *"]: + spans_converted = _ffi.cast("Span *", spans) result = _lib.spanset_make_free(spans_converted, count, normalize, order) _check_error() return result if result != _ffi.NULL else None -def set_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Set *', s) +def set_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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_spanset(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Set *', s) +def set_spanset(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 value_set_span(value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('Span *', s) +def value_set_span( + value: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], + s: Annotated[_ffi.CData, "Span *"], +) -> Annotated[None, "void"]: + 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() -def value_set(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Set *']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) +def value_set( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "Set *"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.value_set(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_span(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Span *']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) +def value_span( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "Span *"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.value_span(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_spanset(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'SpanSet *']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) +def value_spanset( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "SpanSet *"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.value_spanset(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_width(s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Datum']: - s_converted = _ffi.cast('const Span *', s) +def numspan_width(s: Annotated[_ffi.CData, "const Span *"]) -> Annotated[_ffi.CData, "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 numspanset_width(ss: Annotated[_ffi.CData, 'const SpanSet *'], boundspan: bool) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def numspanset_width(ss: Annotated[_ffi.CData, "const SpanSet *"], boundspan: bool) -> Annotated[_ffi.CData, "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 set_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Datum']: - s_converted = _ffi.cast('const Set *', s) +def set_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[int, 'int']: - s_converted = _ffi.cast('const Set *', s) +def set_mem_size(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[int, "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_subspan(s: Annotated[_ffi.CData, 'const Set *'], minidx: int, maxidx: int) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('Span *') +def set_set_subspan( + s: Annotated[_ffi.CData, "const Set *"], minidx: int, maxidx: int +) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("Span *") _lib.set_set_subspan(s_converted, minidx, maxidx, 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 set_set_span(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('Span *') +def set_set_span(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("Span *") _lib.set_set_span(s_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 set_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Datum']: - s_converted = _ffi.cast('const Set *', s) +def set_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_ffi.CData, 'Datum *']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('Datum *') +def set_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[_ffi.CData, "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: @@ -13992,482 +15870,599 @@ def set_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[_f return None -def set_vals(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Datum *']: - s_converted = _ffi.cast('const Set *', s) +def set_vals(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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 set_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Datum *']: - s_converted = _ffi.cast('const Set *', s) +def set_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_lower(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_mem_size(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[int, "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_sps(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'const Span **']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_sps(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 spanset_upper(ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_upper(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 datespan_set_tstzspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) +def datespan_set_tstzspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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_set_intspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) +def floatspan_set_intspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) _lib.floatspan_set_intspan(s1_converted, s2_converted) _check_error() -def intspan_set_floatspan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) +def intspan_set_floatspan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const Set *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def numset_shift_scale( + s: Annotated[_ffi.CData, "const Set *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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_expand(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def numspan_expand( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Span *"]: + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) result = _lib.numspan_expand(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_shift_scale(s: Annotated[_ffi.CData, 'const Span *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def numspan_shift_scale( + s: Annotated[_ffi.CData, "const Span *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const SpanSet *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def numspanset_shift_scale( + ss: Annotated[_ffi.CData, "const SpanSet *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def set_compact(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) +def span_expand( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_compact(ss: Annotated[_ffi.CData, "const SpanSet *"]) -> Annotated[_ffi.CData, "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 tbox_expand_value(box: Annotated[_ffi.CData, 'const TBox *'], value: Annotated[_ffi.CData, 'Datum'], basetyp: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) - value_converted = _ffi.cast('Datum', value) - basetyp_converted = _ffi.cast('meosType', basetyp) +def tbox_expand_value( + box: Annotated[_ffi.CData, "const TBox *"], + value: Annotated[_ffi.CData, "Datum"], + basetyp: Annotated[_ffi.CData, "meosType"], +) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) + value_converted = _ffi.cast("Datum", value) + basetyp_converted = _ffi.cast("meosType", basetyp) result = _lib.tbox_expand_value(box_converted, value_converted, basetyp_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_textset_text_common(s: Annotated[_ffi.CData, 'const Set *'], txt: str, invert: bool) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def textcat_textset_text_common( + s: Annotated[_ffi.CData, "const Set *"], txt: str, invert: bool +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) txt_converted = cstring2text(txt) result = _lib.textcat_textset_text_common(s_converted, txt_converted, invert) _check_error() return result if result != _ffi.NULL else None -def tstzspan_set_datespan(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) +def tstzspan_set_datespan( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) _lib.tstzspan_set_datespan(s1_converted, s2_converted) _check_error() -def adjacent_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def adjacent_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 adjacent_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def adjacent_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 adjacent_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def adjacent_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 contained_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def contained_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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 contained_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def contained_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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 contained_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def contained_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 result if result != _ffi.NULL else None -def contains_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def contains_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def contains_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def contains_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def contains_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def contains_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 ovadj_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def ovadj_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def left_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def left_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 left_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def left_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def left_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def left_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 left_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def left_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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 left_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def left_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def left_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def left_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 lfnadj_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def lfnadj_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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 overleft_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def overleft_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def overleft_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def overleft_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 -def overleft_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def overleft_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 overleft_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def overleft_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def overleft_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def overleft_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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 overleft_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overleft_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 overright_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def overright_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def overright_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def overright_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 overright_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def overright_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 overright_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def overright_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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() return result if result != _ffi.NULL else None -def overright_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def overright_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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 overright_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def overright_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 right_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def right_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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 right_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def right_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 right_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def right_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[bool, "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 right_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[bool, 'bool']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def right_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[bool, "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 right_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def right_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 right_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def right_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[bool, "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 bbox_type(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - bboxtype_converted = _ffi.cast('meosType', bboxtype) +def bbox_type(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[bool, "bool"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) result = _lib.bbox_type(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_get_size(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'size_t']: - bboxtype_converted = _ffi.cast('meosType', bboxtype) +def bbox_get_size(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "size_t"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) result = _lib.bbox_get_size(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_max_dims(bboxtype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int']: - bboxtype_converted = _ffi.cast('meosType', bboxtype) +def bbox_max_dims(bboxtype: Annotated[_ffi.CData, "meosType"]) -> Annotated[int, "int"]: + bboxtype_converted = _ffi.cast("meosType", bboxtype) result = _lib.bbox_max_dims(bboxtype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_eq(box1: Annotated[_ffi.CData, 'const void *'], box2: Annotated[_ffi.CData, 'const void *'], temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[bool, 'bool']: - box1_converted = _ffi.cast('const void *', box1) - box2_converted = _ffi.cast('const void *', box2) - temptype_converted = _ffi.cast('meosType', temptype) +def temporal_bbox_eq( + box1: Annotated[_ffi.CData, "const void *"], + box2: Annotated[_ffi.CData, "const void *"], + temptype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[bool, "bool"]: + box1_converted = _ffi.cast("const void *", box1) + box2_converted = _ffi.cast("const void *", box2) + temptype_converted = _ffi.cast("meosType", temptype) result = _lib.temporal_bbox_eq(box1_converted, box2_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_cmp(box1: Annotated[_ffi.CData, 'const void *'], box2: Annotated[_ffi.CData, 'const void *'], temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[int, 'int']: - box1_converted = _ffi.cast('const void *', box1) - box2_converted = _ffi.cast('const void *', box2) - temptype_converted = _ffi.cast('meosType', temptype) +def temporal_bbox_cmp( + box1: Annotated[_ffi.CData, "const void *"], + box2: Annotated[_ffi.CData, "const void *"], + temptype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[int, "int"]: + box1_converted = _ffi.cast("const void *", box1) + box2_converted = _ffi.cast("const void *", box2) + temptype_converted = _ffi.cast("meosType", temptype) result = _lib.temporal_bbox_cmp(box1_converted, box2_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def bbox_union_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: @@ -14475,360 +16470,455 @@ def inter_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ff return None -def intersection_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def intersection_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 intersection_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Span *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def intersection_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def intersection_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def intersection_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 intersection_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def intersection_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 intersection_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def intersection_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def intersection_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def intersection_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def mi_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - out_result = _ffi.new('Span *') +def mi_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 out_result, result if out_result!= _ffi.NULL else None + return out_result, result if out_result != _ffi.NULL else None - -def minus_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def minus_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 minus_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def minus_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def minus_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def minus_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 minus_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def minus_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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 minus_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def minus_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def minus_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def minus_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 super_union_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Span *']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def super_union_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def union_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) result = _lib.union_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'SpanSet *']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def union_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def union_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def union_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def union_value_set(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Set *', s) +def union_value_set( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Set *"]: + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) result = _lib.union_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_value_span(value: Annotated[_ffi.CData, 'Datum'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'SpanSet *']: - value_converted = _ffi.cast('Datum', value) - s_converted = _ffi.cast('const Span *', s) +def union_value_span( + value: Annotated[_ffi.CData, "Datum"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def union_value_spanset(value: Annotated[_ffi.CData, 'Datum'], ss: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - value_converted = _ffi.cast('Datum', value) - ss_converted = _ffi.cast('const SpanSet *', ss) +def union_value_spanset( + value: Annotated[_ffi.CData, "Datum"], ss: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 distance_set_set(s1: Annotated[_ffi.CData, 'const Set *'], s2: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Datum']: - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) +def distance_set_set( + s1: Annotated[_ffi.CData, "const Set *"], s2: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def distance_set_value(s: Annotated[_ffi.CData, 'const Set *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - s_converted = _ffi.cast('const Set *', s) - value_converted = _ffi.cast('Datum', value) +def distance_set_value( + s: Annotated[_ffi.CData, "const Set *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 distance_span_span(s1: Annotated[_ffi.CData, 'const Span *'], s2: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Datum']: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) +def distance_span_span( + s1: Annotated[_ffi.CData, "const Span *"], s2: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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 distance_span_value(s: Annotated[_ffi.CData, 'const Span *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - s_converted = _ffi.cast('const Span *', s) - value_converted = _ffi.cast('Datum', value) +def distance_span_value( + s: Annotated[_ffi.CData, "const Span *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def distance_spanset_span(ss: Annotated[_ffi.CData, 'const SpanSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def distance_spanset_span( + ss: Annotated[_ffi.CData, "const SpanSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def distance_spanset_spanset(ss1: Annotated[_ffi.CData, 'const SpanSet *'], ss2: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'Datum']: - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) +def distance_spanset_spanset( + ss1: Annotated[_ffi.CData, "const SpanSet *"], ss2: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 distance_spanset_value(ss: Annotated[_ffi.CData, 'const SpanSet *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const SpanSet *', ss) - value_converted = _ffi.cast('Datum', value) +def distance_spanset_value( + ss: Annotated[_ffi.CData, "const SpanSet *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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 distance_value_value(l: Annotated[_ffi.CData, 'Datum'], r: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Datum']: - l_converted = _ffi.cast('Datum', l) - r_converted = _ffi.cast('Datum', r) - basetype_converted = _ffi.cast('meosType', basetype) +def distance_value_value( + l: Annotated[_ffi.CData, "Datum"], r: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "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() return result if result != _ffi.NULL else None -def spanbase_extent_transfn(state: Annotated[_ffi.CData, 'Span *'], value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Span *']: - state_converted = _ffi.cast('Span *', state) - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) +def spanbase_extent_transfn( + state: Annotated[_ffi.CData, "Span *"], + value: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[_ffi.CData, "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 value_union_transfn(state: Annotated[_ffi.CData, 'Set *'], value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) +def value_union_transfn( + state: Annotated[_ffi.CData, "Set *"], + value: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[_ffi.CData, "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 number_tstzspan_to_tbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], + s: Annotated[_ffi.CData, "const Span *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, 'TBox *']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - t_converted = _ffi.cast('TimestampTz', t) +def number_timestamptz_to_tbox( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], t: int +) -> Annotated[_ffi.CData, "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 tbox_set(s: Annotated[_ffi.CData, 'const Span *'], p: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Span *', s) - p_converted = _ffi.cast('const Span *', p) - box_converted = _ffi.cast('TBox *', box) +def tbox_set( + s: Annotated[_ffi.CData, "const Span *"], + p: Annotated[_ffi.CData, "const Span *"], + box: Annotated[_ffi.CData, "TBox *"], +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - box_converted = _ffi.cast('TBox *', box) +def float_set_tbox(d: float, box: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: + box_converted = _ffi.cast("TBox *", box) _lib.float_set_tbox(d, box_converted) _check_error() -def int_set_tbox(i: int, box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - box_converted = _ffi.cast('TBox *', box) +def int_set_tbox(i: int, box: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: + box_converted = _ffi.cast("TBox *", box) _lib.int_set_tbox(i, box_converted) _check_error() -def number_set_tbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - box_converted = _ffi.cast('TBox *', box) +def number_set_tbox( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + 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_tbox(value: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) +def number_tbox( + value: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "TBox *"]: + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.number_tbox(value_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def numset_set_tbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('TBox *', box) +def numset_set_tbox( + s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - span_converted = _ffi.cast('const Span *', span) - box_converted = _ffi.cast('TBox *', box) +def numspan_set_tbox( + span: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + span_converted = _ffi.cast("const Span *", span) + box_converted = _ffi.cast("TBox *", box) _lib.numspan_set_tbox(span_converted, box_converted) _check_error() -def timestamptz_set_tbox(t: int, box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - t_converted = _ffi.cast('TimestampTz', t) - box_converted = _ffi.cast('TBox *', box) +def timestamptz_set_tbox(t: int, box: Annotated[_ffi.CData, "TBox *"]) -> Annotated[None, "void"]: + 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_tbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('TBox *', box) +def tstzset_set_tbox( + s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + s_converted = _ffi.cast("const Set *", s) + box_converted = _ffi.cast("TBox *", box) _lib.tstzset_set_tbox(s_converted, box_converted) _check_error() -def tstzspan_set_tbox(s: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('TBox *', box) +def tstzspan_set_tbox( + s: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + s_converted = _ffi.cast("const Span *", s) + box_converted = _ffi.cast("TBox *", box) _lib.tstzspan_set_tbox(s_converted, box_converted) _check_error() -def tbox_shift_scale_value(box: Annotated[_ffi.CData, 'const TBox *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TBox *']: - box_converted = _ffi.cast('const TBox *', box) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def tbox_shift_scale_value( + box: Annotated[_ffi.CData, "const TBox *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "TBox *"]: + box_converted = _ffi.cast("const TBox *", box) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) result = _lib.tbox_shift_scale_value(box_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_expand(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('TBox *', box2) +def tbox_expand( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("TBox *", box2) _lib.tbox_expand(box1_converted, box2_converted) _check_error() -def inter_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[_ffi.CData, "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: @@ -14836,457 +16926,540 @@ def inter_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated return None -def tboolinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tboolinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tboolseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tboolseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tboolseqset_in(string: str) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) +def temporal_in(string: str, temptype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + 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 temparr_out(temparr: Annotated[list, 'Temporal **'], count: int, maxdd: int) -> Annotated[_ffi.CData, 'char **']: - temparr_converted = [_ffi.cast('Temporal *', x) for x in temparr] +def temparr_out(temparr: Annotated[list, "Temporal **"], count: int, maxdd: int) -> Annotated[_ffi.CData, "char **"]: + temparr_converted = [_ffi.cast("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 tfloatinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tfloatinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tfloatseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tfloatseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tfloatseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") result = _lib.tfloatseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_in(string: str, temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) +def tinstant_in(string: str, temptype: Annotated[_ffi.CData, "meosType"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], maxdd: int) -> Annotated[str, 'char *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_out(inst: Annotated[_ffi.CData, "const TInstant *"], maxdd: int) -> Annotated[str, "char *"]: + 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_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tintinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tintseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tintseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tintseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tintseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") result = _lib.tintseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_in(string: str, temptype: Annotated[_ffi.CData, 'meosType'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) +def tsequence_in( + string: str, temptype: Annotated[_ffi.CData, "meosType"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) result = _lib.tsequence_in(string_converted, temptype_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_out(seq: Annotated[_ffi.CData, 'const TSequence *'], maxdd: int) -> Annotated[str, 'char *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_out(seq: Annotated[_ffi.CData, "const TSequence *"], maxdd: int) -> Annotated[str, "char *"]: + 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_in(string: str, temptype: Annotated[_ffi.CData, 'meosType'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) +def tsequenceset_in( + string: str, temptype: Annotated[_ffi.CData, "meosType"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) result = _lib.tsequenceset_in(string_converted, temptype_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_out(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], maxdd: int) -> Annotated[str, 'char *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_out(ss: Annotated[_ffi.CData, "const TSequenceSet *"], maxdd: int) -> Annotated[str, "char *"]: + 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_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def ttextinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def ttextseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.ttextseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def ttextseqset_in(string: str) -> Annotated[_ffi.CData, "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_from_mfjson(mfjson: str, temptype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'Temporal *']: - mfjson_converted = mfjson.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) +def temporal_from_mfjson( + mfjson: str, temptype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "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_from_base_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_from_base_temp( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_copy(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - t_converted = _ffi.cast('TimestampTz', t) +def tinstant_make( + value: Annotated[_ffi.CData, "Datum"], temptype: Annotated[_ffi.CData, "meosType"], t: int +) -> Annotated[_ffi.CData, "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 tinstant_make_free(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - t_converted = _ffi.cast('TimestampTz', t) +def tinstant_make_free( + value: Annotated[_ffi.CData, "Datum"], temptype: Annotated[_ffi.CData, "meosType"], t: int +) -> Annotated[_ffi.CData, "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 tsequence_copy(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_copy(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_from_base_temp( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> Annotated[_ffi.CData, "TSequence *"]: + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_from_base_temp(value_converted, temptype_converted, seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzset(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequence *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - s_converted = _ffi.cast('const Set *', s) +def tsequence_from_base_tstzset( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + s: Annotated[_ffi.CData, "const Set *"], +) -> Annotated[_ffi.CData, "TSequence *"]: + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + s_converted = _ffi.cast("const Set *", s) result = _lib.tsequence_from_base_tstzset(value_converted, temptype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzspan(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], s: Annotated[_ffi.CData, 'const Span *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - s_converted = _ffi.cast('const Span *', s) +def tsequence_from_base_tstzspan( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + s: Annotated[_ffi.CData, "const Span *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequence *"]: + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + s_converted = _ffi.cast("const Span *", s) result = _lib.tsequence_from_base_tstzspan(value_converted, temptype_converted, s_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_exp(instants: Annotated[list, 'TInstant **'], count: int, maxcount: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] +def tsequence_make_exp( + instants: Annotated[list, "TInstant **"], + count: int, + maxcount: int, + lower_inc: bool, + upper_inc: bool, + interp: InterpolationType, + normalize: bool, +) -> Annotated[_ffi.CData, "TSequence *"]: + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tsequence_make_exp(instants_converted, count, maxcount, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_free(instants: Annotated[list, 'TInstant **'], count: int, lower_inc: bool, upper_inc: bool, interp: InterpolationType, normalize: bool) -> Annotated[_ffi.CData, 'TSequence *']: - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] +def tsequence_make_free( + instants: Annotated[list, "TInstant **"], + count: int, + lower_inc: bool, + upper_inc: bool, + interp: InterpolationType, + normalize: bool, +) -> Annotated[_ffi.CData, "TSequence *"]: + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] result = _lib.tsequence_make_free(instants_converted, count, lower_inc, upper_inc, interp, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_copy(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_copy(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[list, 'TSequenceSet **'], count: int, totalseqs: int) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seqsets_converted = [_ffi.cast('TSequenceSet *', x) for x in seqsets] +def tseqsetarr_to_tseqset( + seqsets: Annotated[list, "TSequenceSet **"], count: int, totalseqs: int +) -> Annotated[_ffi.CData, "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_temp(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_from_base_temp( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_from_base_temp(value_converted, temptype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_from_base_tstzspanset(value: Annotated[_ffi.CData, 'Datum'], temptype: Annotated[_ffi.CData, 'meosType'], ss: Annotated[_ffi.CData, 'const SpanSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tsequenceset_from_base_tstzspanset( + value: Annotated[_ffi.CData, "Datum"], + temptype: Annotated[_ffi.CData, "meosType"], + ss: Annotated[_ffi.CData, "const SpanSet *"], + interp: InterpolationType, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tsequenceset_from_base_tstzspanset(value_converted, temptype_converted, ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_exp(sequences: Annotated[list, 'TSequence **'], count: int, maxcount: int, normalize: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] +def tsequenceset_make_exp( + sequences: Annotated[list, "TSequence **"], count: int, maxcount: int, normalize: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + sequences_converted = [_ffi.cast("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: Annotated[list, 'TSequence **'], count: int, normalize: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] +def tsequenceset_make_free( + sequences: Annotated[list, "TSequence **"], count: int, normalize: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('Span *', s) +def temporal_set_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const TInstant *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - inst_converted = _ffi.cast('const TInstant *', inst) - s_converted = _ffi.cast('Span *', s) +def tinstant_set_tstzspan( + inst: Annotated[_ffi.CData, "const TInstant *"], s: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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_set_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('TBox *', box) +def tnumber_set_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("TBox *", box) _lib.tnumber_set_tbox(temp_converted, box_converted) _check_error() -def tnumberinst_set_tbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('TBox *', box) +def tnumberinst_set_tbox( + inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + inst_converted = _ffi.cast("const TInstant *", inst) + box_converted = _ffi.cast("TBox *", box) _lib.tnumberinst_set_tbox(inst_converted, box_converted) _check_error() -def tnumberseq_set_tbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('TBox *', box) +def tnumberseq_set_tbox( + seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("TBox *", box) _lib.tnumberseq_set_tbox(seq_converted, box_converted) _check_error() -def tnumberseqset_set_tbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'TBox *']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('TBox *', box) +def tnumberseqset_set_tbox( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "TBox *"] +) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("TBox *", box) _lib.tnumberseqset_set_tbox(ss_converted, box_converted) _check_error() -def tsequence_set_tstzspan(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('Span *', s) +def tsequence_set_tstzspan( + seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('Span *', s) +def tsequenceset_set_tstzspan( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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_inst(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_inst(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_end_inst(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Datum']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_inst_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'const TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_inst_n( + temp: Annotated[_ffi.CData, "const Temporal *"], n: int +) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_inst_n(temp_converted, n) _check_error() return result if result != _ffi.NULL else None -def temporal_insts_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'const TInstant **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_insts_p( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "const TInstant **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_insts_p(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_max_inst_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_max_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_max_inst_p(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_max_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Datum']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_max_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'size_t']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_mem_size(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_inst_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_min_inst_p(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_min_inst_p(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_min_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Datum']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_min_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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_sequences_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'const TSequence **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_sequences_p( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "const TSequence **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_sequences_p(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_set_bbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('void *', box) +def temporal_set_bbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "void *"] +) -> Annotated[None, "void"]: + 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_start_inst(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'const TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_inst(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_start_inst(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_value(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Datum']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_value(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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 temporal_values_p(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_values_p( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "Datum *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_values_p(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> Annotated[_ffi.CData, 'Datum *']: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('Datum *') +def temporal_value_n(temp: Annotated[_ffi.CData, "const Temporal *"], n: int) -> Annotated[_ffi.CData, "Datum *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("Datum *") result = _lib.temporal_value_n(temp_converted, n, out_result) _check_error() if result: @@ -15294,69 +17467,79 @@ def temporal_value_n(temp: Annotated[_ffi.CData, 'const Temporal *'], n: int) -> return None -def temporal_values(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_values( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "Datum *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, 'uint32']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_hash(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[_ffi.CData, 'const TInstant **'], Annotated[_ffi.CData, 'int']]: - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') +def tinstant_insts( + inst: Annotated[_ffi.CData, "const TInstant *"], +) -> tuple[Annotated[_ffi.CData, "const TInstant **"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('void *', box) +def tinstant_set_bbox( + inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "void *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'SpanSet *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_time(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') +def tinstant_timestamps( + inst: Annotated[_ffi.CData, "const TInstant *"], +) -> tuple[Annotated[int, "TimestampTz *"], Annotated[_ffi.CData, "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_p(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'Datum']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_value_p(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "Datum"]: + inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tinstant_value_p(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_value(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'Datum']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_value(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], t: int) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const TInstant *"], t: int +) -> Annotated[_ffi.CData, "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: @@ -15364,154 +17547,166 @@ def tinstant_value_at_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *' return None -def tinstant_values_p(inst: Annotated[_ffi.CData, 'const TInstant *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') +def tinstant_values_p( + inst: Annotated[_ffi.CData, "const TInstant *"], +) -> tuple[Annotated[_ffi.CData, "Datum *"], Annotated[_ffi.CData, "int"]]: + inst_converted = _ffi.cast("const TInstant *", inst) + count = _ffi.new("int *") result = _lib.tinstant_values_p(inst_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_set_span(temp: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'Span *']) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('Span *', span) +def tnumber_set_span( + temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "Span *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'SpanSet *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tnumberinst_valuespans(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "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_avg_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, 'double']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_avg_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "double"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tnumberseq_avg_val(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_valuespans(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'SpanSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_valuespans(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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_avg_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_avg_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "double"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tnumberseqset_avg_val(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_valuespans(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_valuespans(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'Interval *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_duration(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, 'TimestampTz']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_end_timestamptz(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, 'uint32']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_hash(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "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_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant **']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_insts_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant **"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_insts_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_inst_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_max_inst_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_max_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'Datum']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_max_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'const TInstant *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_min_inst_p(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "const TInstant *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_min_inst_p(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_val(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'Datum']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_min_val(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tsequence_segments( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'const TSequence **'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tsequence_seqs( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[_ffi.CData, "const TSequence **"], Annotated[_ffi.CData, "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_start_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, 'TimestampTz']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_start_timestamptz(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'SpanSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_time(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tsequence_timestamps( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[int, "TimestampTz *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Datum *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') +def tsequence_value_at_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -15519,123 +17714,139 @@ def tsequence_value_at_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence * return None -def tsequence_values_p(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tsequence_values_p( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[_ffi.CData, "Datum *"], Annotated[_ffi.CData, "int"]]: + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") result = _lib.tsequence_values_p(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequenceset_duration(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], boundspan: bool) -> Annotated[_ffi.CData, 'Interval *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_duration( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], boundspan: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_end_timestamptz(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'uint32']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_hash(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], n: int) -> Annotated[_ffi.CData, 'const TInstant *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_inst_n( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], n: int +) -> Annotated[_ffi.CData, "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_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant **']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_insts_p( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "const TInstant **"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_insts_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_inst_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_max_inst_p( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "const TInstant *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_max_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_max_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TInstant *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_min_inst_p( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "const TInstant *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_min_inst_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_val(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'Datum']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_min_val(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_num_instants(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'int']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_num_timestamps(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tsequenceset_segments( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'const TSequence **']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_sequences_p( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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_start_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'TimestampTz']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_start_timestamptz(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'SpanSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_time(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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_timestamptz_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], n: int) -> int: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - out_result = _ffi.new('TimestampTz *') +def tsequenceset_timestamptz_n(ss: Annotated[_ffi.CData, "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: @@ -15643,18 +17854,22 @@ def tsequenceset_timestamptz_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'] return None -def tsequenceset_timestamps(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[int, 'TimestampTz *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tsequenceset_timestamps( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> tuple[Annotated[int, "TimestampTz *"], Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Datum *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') +def tsequenceset_value_at_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -15662,9 +17877,9 @@ def tsequenceset_value_at_timestamptz(ss: Annotated[_ffi.CData, 'const TSequence return None -def tsequenceset_value_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], n: int) -> Annotated[_ffi.CData, 'Datum *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - out_result = _ffi.new('Datum *') +def tsequenceset_value_n(ss: Annotated[_ffi.CData, "const TSequenceSet *"], n: int) -> Annotated[_ffi.CData, "Datum *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + out_result = _ffi.new("Datum *") result = _lib.tsequenceset_value_n(ss_converted, n, out_result) _check_error() if result: @@ -15672,512 +17887,654 @@ def tsequenceset_value_n(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], n: i return None -def tsequenceset_values_p(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'Datum *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tsequenceset_values_p( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> tuple[Annotated[_ffi.CData, "Datum *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") result = _lib.tsequenceset_values_p(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_restart(temp: Annotated[_ffi.CData, 'Temporal *'], count: int) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('Temporal *', temp) +def temporal_restart(temp: Annotated[_ffi.CData, "Temporal *"], count: int) -> Annotated[None, "void"]: + temp_converted = _ffi.cast("Temporal *", temp) _lib.temporal_restart(temp_converted, count) _check_error() -def temporal_tsequence(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_tsequence( + temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_tsequence(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def temporal_tsequenceset(temp: Annotated[_ffi.CData, 'const Temporal *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_tsequenceset( + temp: Annotated[_ffi.CData, "const Temporal *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_tsequenceset(temp_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_shift_time(inst: Annotated[_ffi.CData, 'const TInstant *'], interv: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - interv_converted = _ffi.cast('const Interval *', interv) +def tinstant_shift_time( + inst: Annotated[_ffi.CData, "const TInstant *"], interv: Annotated[_ffi.CData, "const Interval *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_to_tsequence( + inst: Annotated[_ffi.CData, "const TInstant *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tinstant_to_tsequence(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequence_free(inst: Annotated[_ffi.CData, 'TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - inst_converted = _ffi.cast('TInstant *', inst) +def tinstant_to_tsequence_free( + inst: Annotated[_ffi.CData, "TInstant *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequence *"]: + inst_converted = _ffi.cast("TInstant *", inst) result = _lib.tinstant_to_tsequence_free(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequenceset(inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tinstant_to_tsequenceset( + inst: Annotated[_ffi.CData, "const TInstant *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tinstant_to_tsequenceset(inst_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tnumber_shift_scale_value(temp: Annotated[_ffi.CData, 'const Temporal *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def tnumber_shift_scale_value( + temp: Annotated[_ffi.CData, "const Temporal *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], shift: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - shift_converted = _ffi.cast('Datum', shift) +def tnumberinst_shift_value( + inst: Annotated[_ffi.CData, "const TInstant *"], shift: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], shift: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) +def tnumberseq_shift_scale_value( + seq: Annotated[_ffi.CData, "const TSequence *"], + shift: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], start: Annotated[_ffi.CData, 'Datum'], width: Annotated[_ffi.CData, 'Datum'], hasshift: bool, haswidth: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - start_converted = _ffi.cast('Datum', start) - width_converted = _ffi.cast('Datum', width) +def tnumberseqset_shift_scale_value( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], + start: Annotated[_ffi.CData, "Datum"], + width: Annotated[_ffi.CData, "Datum"], + hasshift: bool, + haswidth: bool, +) -> Annotated[_ffi.CData, "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_restart(seq: Annotated[_ffi.CData, 'TSequence *'], count: int) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('TSequence *', seq) +def tsequence_restart(seq: Annotated[_ffi.CData, "TSequence *"], count: int) -> Annotated[None, "void"]: + seq_converted = _ffi.cast("TSequence *", seq) _lib.tsequence_restart(seq_converted, count) _check_error() -def tsequence_set_interp(seq: Annotated[_ffi.CData, 'const TSequence *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_set_interp( + seq: Annotated[_ffi.CData, "const TSequence *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "Temporal *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_set_interp(seq_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequence_shift_scale_time(seq: Annotated[_ffi.CData, 'const TSequence *'], shift: Annotated[_ffi.CData, 'const Interval *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - shift_converted = _ffi.cast('const Interval *', shift) - duration_converted = _ffi.cast('const Interval *', duration) +def tsequence_shift_scale_time( + seq: Annotated[_ffi.CData, "const TSequence *"], + shift: Annotated[_ffi.CData, "const Interval *"], + duration: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], from_: int, to: int, lower_inc: bool, upper_inc: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_subseq( + seq: Annotated[_ffi.CData, "const TSequence *"], from_: int, to: int, lower_inc: bool, upper_inc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TInstant *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_to_tinstant(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_to_tsequenceset( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> Annotated[_ffi.CData, "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_free(seq: Annotated[_ffi.CData, 'TSequence *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seq_converted = _ffi.cast('TSequence *', seq) +def tsequence_to_tsequenceset_free( + seq: Annotated[_ffi.CData, "TSequence *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_to_tsequenceset_interp( + seq: Annotated[_ffi.CData, "const TSequence *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tsequence_to_tsequenceset_interp(seq_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restart(ss: Annotated[_ffi.CData, 'TSequenceSet *'], count: int) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('TSequenceSet *', ss) +def tsequenceset_restart(ss: Annotated[_ffi.CData, "TSequenceSet *"], count: int) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("TSequenceSet *", ss) _lib.tsequenceset_restart(ss_converted, count) _check_error() -def tsequenceset_set_interp(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], interp: InterpolationType) -> Annotated[_ffi.CData, 'Temporal *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_set_interp( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], interp: InterpolationType +) -> Annotated[_ffi.CData, "Temporal *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_set_interp(ss_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_shift_scale_time(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], start: Annotated[_ffi.CData, 'const Interval *'], duration: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - start_converted = _ffi.cast('const Interval *', start) - duration_converted = _ffi.cast('const Interval *', duration) +def tsequenceset_shift_scale_time( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], + start: Annotated[_ffi.CData, "const Interval *"], + duration: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequence *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_to_discrete(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_to_linear( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_to_step(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TInstant *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_to_tinstant(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequence *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_to_tsequence( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'Temporal *']: - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) +def tinstant_merge( + inst1: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] +) -> Annotated[_ffi.CData, "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: Annotated[list, 'TInstant **'], count: int) -> Annotated[_ffi.CData, 'Temporal *']: - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] +def tinstant_merge_array(instants: Annotated[list, "TInstant **"], count: int) -> Annotated[_ffi.CData, "Temporal *"]: + instants_converted = [_ffi.cast("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: Annotated[_ffi.CData, 'TSequence *'], inst: Annotated[_ffi.CData, 'const TInstant *'], maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'], expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('TSequence *', seq) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) +def tsequence_append_tinstant( + seq: Annotated[_ffi.CData, "TSequence *"], + inst: Annotated[_ffi.CData, "const TInstant *"], + maxdist: float, + maxt: Annotated[_ffi.CData, "const Interval *"], + expand: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) +def tsequence_append_tsequence( + seq1: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"], expand: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + seq1_converted = _ffi.cast("const 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: Annotated[_ffi.CData, 'const TSequence *'], t: int, connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tsequence_delete_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Set *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Set *', s) +def tsequence_delete_tstzset( + seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Set *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Span *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Span *', s) +def tsequence_delete_tstzspan( + seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Span *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tsequence_delete_tstzspanset( + seq: Annotated[_ffi.CData, "const TSequence *"], ss: Annotated[_ffi.CData, "const SpanSet *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *'], connect: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) +def tsequence_insert( + seq1: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"], connect: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'Temporal *']: - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) +def tsequence_merge( + seq1: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] +) -> Annotated[_ffi.CData, "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: Annotated[list, 'TSequence **'], count: int) -> Annotated[_ffi.CData, 'Temporal *']: - sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] +def tsequence_merge_array( + sequences: Annotated[list, "TSequence **"], count: int +) -> Annotated[_ffi.CData, "Temporal *"]: + sequences_converted = [_ffi.cast("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: Annotated[_ffi.CData, 'TSequenceSet *'], inst: Annotated[_ffi.CData, 'const TInstant *'], maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *'], expand: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('TSequenceSet *', ss) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) +def tsequenceset_append_tinstant( + ss: Annotated[_ffi.CData, "TSequenceSet *"], + inst: Annotated[_ffi.CData, "const TInstant *"], + maxdist: float, + maxt: Annotated[_ffi.CData, "const Interval *"], + expand: bool, +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'TSequenceSet *'], seq: Annotated[_ffi.CData, 'const TSequence *'], expand: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('TSequenceSet *', ss) - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequenceset_append_tsequence( + ss: Annotated[_ffi.CData, "TSequenceSet *"], seq: Annotated[_ffi.CData, "const TSequence *"], expand: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def tsequenceset_delete_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) +def tsequenceset_delete_tstzset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def tsequenceset_delete_tstzspan( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], ps: Annotated[_ffi.CData, 'const SpanSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - ps_converted = _ffi.cast('const SpanSet *', ps) +def tsequenceset_delete_tstzspanset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], ps: Annotated[_ffi.CData, "const SpanSet *"] +) -> Annotated[_ffi.CData, "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 tsequenceset_insert(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) +def tsequenceset_insert( + ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] +) -> Annotated[_ffi.CData, "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 tsequenceset_merge(ss1: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) +def tsequenceset_merge( + ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] +) -> Annotated[_ffi.CData, "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: Annotated[list, 'TSequenceSet **'], count: int) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seqsets_converted = [_ffi.cast('TSequenceSet *', x) for x in seqsets] +def tsequenceset_merge_array( + seqsets: Annotated[list, "TSequenceSet **"], count: int +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + seqsets_converted = [_ffi.cast("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 tsequence_expand_bbox(seq: Annotated[_ffi.CData, 'TSequence *'], inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('TSequence *', seq) - inst_converted = _ffi.cast('const TInstant *', inst) +def tsequence_expand_bbox( + seq: Annotated[_ffi.CData, "TSequence *"], inst: Annotated[_ffi.CData, "const TInstant *"] +) -> Annotated[None, "void"]: + 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_set_bbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('void *', box) +def tsequence_set_bbox( + seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "void *"] +) -> Annotated[None, "void"]: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("void *", box) _lib.tsequence_set_bbox(seq_converted, box_converted) _check_error() -def tsequenceset_expand_bbox(ss: Annotated[_ffi.CData, 'TSequenceSet *'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('TSequenceSet *', ss) - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequenceset_expand_bbox( + ss: Annotated[_ffi.CData, "TSequenceSet *"], seq: Annotated[_ffi.CData, "const TSequence *"] +) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("TSequenceSet *", ss) + seq_converted = _ffi.cast("const TSequence *", seq) _lib.tsequenceset_expand_bbox(ss_converted, seq_converted) _check_error() -def tsequenceset_set_bbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'void *']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('void *', box) +def tsequenceset_set_bbox( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "void *"] +) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("void *", box) _lib.tsequenceset_set_bbox(ss_converted, box_converted) _check_error() -def tcontseq_after_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tcontseq_after_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tcontseq_after_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tcontseq_before_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tcontseq_before_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tcontseq_before_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tcontseq_restrict_minmax(seq: Annotated[_ffi.CData, 'const TSequence *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tcontseq_restrict_minmax( + seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool +) -> Annotated[_ffi.CData, "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 tdiscseq_after_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tdiscseq_after_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tdiscseq_after_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tdiscseq_before_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tdiscseq_before_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tdiscseq_before_timestamptz(seq_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tdiscseq_restrict_minmax(seq: Annotated[_ffi.CData, 'const TSequence *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tdiscseq_restrict_minmax( + seq: Annotated[_ffi.CData, "const TSequence *"], min: bool, atfunc: bool +) -> Annotated[_ffi.CData, "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 temporal_bbox_restrict_set(temp: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_bbox_restrict_set( + temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Temporal *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_restrict_minmax( + temp: Annotated[_ffi.CData, "const Temporal *"], min: bool, atfunc: bool +) -> Annotated[_ffi.CData, "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_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_restrict_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_restrict_tstzset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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_tstzspan(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_restrict_tstzspan( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_restrict_tstzspanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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_value(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def temporal_restrict_value( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], set: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_restrict_values( + temp: Annotated[_ffi.CData, "const Temporal *"], set: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'Datum *']: - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') +def temporal_value_at_timestamptz( + temp: Annotated[_ffi.CData, "const Temporal *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "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: @@ -16185,859 +18542,1117 @@ def temporal_value_at_timestamptz(temp: Annotated[_ffi.CData, 'const Temporal *' return None -def tinstant_after_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - t_converted = _ffi.cast('TimestampTz', t) +def tinstant_after_timestamptz( + inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tinstant_after_timestamptz(inst_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tinstant_before_timestamptz(inst: Annotated[_ffi.CData, 'const TInstant *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - t_converted = _ffi.cast('TimestampTz', t) +def tinstant_before_timestamptz( + inst: Annotated[_ffi.CData, "const TInstant *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tinstant_before_timestamptz(inst_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzspan(inst: Annotated[_ffi.CData, 'const TInstant *'], period: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - period_converted = _ffi.cast('const Span *', period) +def tinstant_restrict_tstzspan( + inst: Annotated[_ffi.CData, "const TInstant *"], period: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tinstant_restrict_tstzspanset( + inst: Annotated[_ffi.CData, "const TInstant *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - t_converted = _ffi.cast('TimestampTz', t) +def tinstant_restrict_timestamptz( + inst: Annotated[_ffi.CData, "const TInstant *"], t: int, atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - s_converted = _ffi.cast('const Set *', s) +def tinstant_restrict_tstzset( + inst: Annotated[_ffi.CData, "const TInstant *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) +def tinstant_restrict_value( + inst: Annotated[_ffi.CData, "const TInstant *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], set: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - set_converted = _ffi.cast('const Set *', set) +def tinstant_restrict_values( + inst: Annotated[_ffi.CData, "const TInstant *"], set: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) +def tnumber_restrict_span( + temp: Annotated[_ffi.CData, "const Temporal *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const Temporal *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumber_restrict_spanset( + temp: Annotated[_ffi.CData, "const Temporal *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - span_converted = _ffi.cast('const Span *', span) +def tnumberinst_restrict_span( + inst: Annotated[_ffi.CData, "const TInstant *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TInstant *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumberinst_restrict_spanset( + inst: Annotated[_ffi.CData, "const TInstant *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], span: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - span_converted = _ffi.cast('const Span *', span) +def tnumberseqset_restrict_span( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], span: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], spanset: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - spanset_converted = _ffi.cast('const SpanSet *', spanset) +def tnumberseqset_restrict_spanset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], spanset: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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 tsequence_at_timestamptz(seq: Annotated[_ffi.CData, 'const TSequence *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) +def tsequence_at_timestamptz( + seq: Annotated[_ffi.CData, "const TSequence *"], t: int +) -> Annotated[_ffi.CData, "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_tstzspan(seq: Annotated[_ffi.CData, 'const TSequence *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Span *', s) +def tsequence_restrict_tstzspan( + seq: Annotated[_ffi.CData, "const TSequence *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], ss: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tsequence_restrict_tstzspanset( + seq: Annotated[_ffi.CData, "const TSequence *"], ss: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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 tsequenceset_after_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def tsequenceset_after_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tsequenceset_after_timestamptz(ss_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_before_timestamptz(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, strict: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def tsequenceset_before_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, strict: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tsequenceset_before_timestamptz(ss_converted, t_converted, strict) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_minmax(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], min: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_restrict_minmax( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], min: bool, atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Span *', s) +def tsequenceset_restrict_tstzspan( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Span *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], ps: Annotated[_ffi.CData, 'const SpanSet *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - ps_converted = _ffi.cast('const SpanSet *', ps) +def tsequenceset_restrict_tstzspanset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], ps: Annotated[_ffi.CData, "const SpanSet *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], t: int, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) +def tsequenceset_restrict_timestamptz( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], t: int, atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) +def tsequenceset_restrict_tstzset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], value: Annotated[_ffi.CData, 'Datum'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) +def tsequenceset_restrict_value( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], value: Annotated[_ffi.CData, "Datum"], atfunc: bool +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], s: Annotated[_ffi.CData, 'const Set *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) +def tsequenceset_restrict_values( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], s: Annotated[_ffi.CData, "const Set *"], atfunc: bool +) -> Annotated[_ffi.CData, "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 tinstant_cmp(inst1: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, 'int']: - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) +def tinstant_cmp( + inst1: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TInstant *'], inst2: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[bool, 'bool']: - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) +def tinstant_eq( + inst1: Annotated[_ffi.CData, "const TInstant *"], inst2: Annotated[_ffi.CData, "const TInstant *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[int, 'int']: - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) +def tsequence_cmp( + seq1: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequence *'], seq2: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[bool, 'bool']: - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) +def tsequence_eq( + seq1: Annotated[_ffi.CData, "const TSequence *"], seq2: Annotated[_ffi.CData, "const TSequence *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[int, 'int']: - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) +def tsequenceset_cmp( + ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] +) -> Annotated[int, "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: Annotated[_ffi.CData, 'const TSequenceSet *'], ss2: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[bool, 'bool']: - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) +def tsequenceset_eq( + ss1: Annotated[_ffi.CData, "const TSequenceSet *"], ss2: Annotated[_ffi.CData, "const TSequenceSet *"] +) -> Annotated[bool, "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 always_eq_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_eq_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_eq_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 always_ne_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_ne_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_ne_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 always_ge_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_ge_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_ge_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 always_gt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_gt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_gt_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 always_le_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_le_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_le_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 always_lt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 always_lt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def always_lt_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_eq_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_eq_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_eq_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_ne_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_ne_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_ne_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_ge_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ge_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_ge_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_ge_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_gt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_gt_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_gt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_gt_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_le_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_le_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_le_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_le_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 ever_lt_base_temporal(value: Annotated[_ffi.CData, 'Datum'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - value_converted = _ffi.cast('Datum', value) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_lt_base_temporal( + value: Annotated[_ffi.CData, "Datum"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "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 ever_lt_temporal_base(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def ever_lt_temporal_base( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[int, "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 tnumberinst_abs(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tnumberinst_abs(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_abs(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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 tnumberseq_angular_difference(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_angular_difference( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> Annotated[_ffi.CData, "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 tnumberseq_delta_value(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_delta_value(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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_abs(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_abs(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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 tnumberseqset_angular_difference(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequence *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_angular_difference( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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 tnumberseqset_delta_value(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_delta_value( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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 tdistance_tnumber_number(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def tdistance_tnumber_number( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) result = _lib.tdistance_tnumber_number(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tbox_tbox(box1: Annotated[_ffi.CData, 'const TBox *'], box2: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, 'double']: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def nad_tbox_tbox( + box1: Annotated[_ffi.CData, "const TBox *"], box2: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[float, "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_tnumber_number(temp: Annotated[_ffi.CData, 'const Temporal *'], value: Annotated[_ffi.CData, 'Datum']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) +def nad_tnumber_number( + temp: Annotated[_ffi.CData, "const Temporal *"], value: Annotated[_ffi.CData, "Datum"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) result = _lib.nad_tnumber_number(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_tbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const TBox *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def nad_tnumber_tbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const TBox *"] +) -> Annotated[float, "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_tnumber_tnumber(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nad_tnumber_tnumber( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "double"]: + 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 -def tnumberseq_integral(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, 'double']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_integral(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, 'double']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tnumberseq_twavg(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_integral(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tnumberseqset_twavg(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "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 temporal_compact(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_compact(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tsequence_compact(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_compact(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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 temporal_skiplist_make() -> Annotated[_ffi.CData, 'SkipList *']: +def temporal_skiplist_make() -> Annotated[_ffi.CData, "SkipList *"]: result = _lib.temporal_skiplist_make() _check_error() return result if result != _ffi.NULL else None -def skiplist_search(list: Annotated[_ffi.CData, 'SkipList *'], key: Annotated[_ffi.CData, 'void *'], value: Annotated[_ffi.CData, 'void *']) -> Annotated[int, 'int']: - list_converted = _ffi.cast('SkipList *', list) - key_converted = _ffi.cast('void *', key) - value_converted = _ffi.cast('void *', value) +def skiplist_search( + list: Annotated[_ffi.CData, "SkipList *"], + key: Annotated[_ffi.CData, "void *"], + value: Annotated[_ffi.CData, "void *"], +) -> Annotated[int, "int"]: + list_converted = _ffi.cast("SkipList *", list) + key_converted = _ffi.cast("void *", key) + value_converted = _ffi.cast("void *", value) result = _lib.skiplist_search(list_converted, key_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def skiplist_free(list: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[None, 'void']: - list_converted = _ffi.cast('SkipList *', list) +def skiplist_free(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[None, "void"]: + list_converted = _ffi.cast("SkipList *", list) _lib.skiplist_free(list_converted) _check_error() -def skiplist_splice(list: Annotated[_ffi.CData, 'SkipList *'], keys: Annotated[list, 'void **'], values: Annotated[list, 'void **'], count: int, func: Annotated[_ffi.CData, 'datum_func2'], crossings: bool, sktype: Annotated[_ffi.CData, 'SkipListType']) -> Annotated[None, 'void']: - list_converted = _ffi.cast('SkipList *', list) - keys_converted = [_ffi.cast('void *', x) for x in keys] - values_converted = [_ffi.cast('void *', x) for x in values] - func_converted = _ffi.cast('datum_func2', func) - sktype_converted = _ffi.cast('SkipListType', sktype) - _lib.skiplist_splice(list_converted, keys_converted, values_converted, count, func_converted, crossings, sktype_converted) +def skiplist_splice( + list: Annotated[_ffi.CData, "SkipList *"], + keys: Annotated[list, "void **"], + values: Annotated[list, "void **"], + count: int, + func: Annotated[_ffi.CData, "datum_func2"], + crossings: bool, + sktype: Annotated[_ffi.CData, "SkipListType"], +) -> Annotated[None, "void"]: + list_converted = _ffi.cast("SkipList *", list) + keys_converted = [_ffi.cast("void *", x) for x in keys] + values_converted = [_ffi.cast("void *", x) for x in values] + func_converted = _ffi.cast("datum_func2", func) + sktype_converted = _ffi.cast("SkipListType", sktype) + _lib.skiplist_splice( + list_converted, keys_converted, values_converted, count, func_converted, crossings, sktype_converted + ) _check_error() -def temporal_skiplist_splice(list: Annotated[_ffi.CData, 'SkipList *'], values: Annotated[list, 'void **'], count: int, func: Annotated[_ffi.CData, 'datum_func2'], crossings: bool) -> Annotated[None, 'void']: - list_converted = _ffi.cast('SkipList *', list) - values_converted = [_ffi.cast('void *', x) for x in values] - func_converted = _ffi.cast('datum_func2', func) +def temporal_skiplist_splice( + list: Annotated[_ffi.CData, "SkipList *"], + values: Annotated[list, "void **"], + count: int, + func: Annotated[_ffi.CData, "datum_func2"], + crossings: bool, +) -> Annotated[None, "void"]: + list_converted = _ffi.cast("SkipList *", list) + values_converted = [_ffi.cast("void *", x) for x in values] + func_converted = _ffi.cast("datum_func2", func) _lib.temporal_skiplist_splice(list_converted, values_converted, count, func_converted, crossings) _check_error() -def skiplist_values(list: Annotated[_ffi.CData, 'SkipList *']) -> Annotated[_ffi.CData, 'void **']: - list_converted = _ffi.cast('SkipList *', list) +def skiplist_values(list: Annotated[_ffi.CData, "SkipList *"]) -> Annotated[_ffi.CData, "void **"]: + list_converted = _ffi.cast("SkipList *", list) result = _lib.skiplist_values(list_converted) _check_error() return result if result != _ffi.NULL else None -def skiplist_keys_values(list: Annotated[_ffi.CData, 'SkipList *'], values: Annotated[list, 'void **']) -> Annotated[_ffi.CData, 'void **']: - list_converted = _ffi.cast('SkipList *', list) - values_converted = [_ffi.cast('void *', x) for x in values] +def skiplist_keys_values( + list: Annotated[_ffi.CData, "SkipList *"], values: Annotated[list, "void **"] +) -> Annotated[_ffi.CData, "void **"]: + list_converted = _ffi.cast("SkipList *", list) + values_converted = [_ffi.cast("void *", x) for x in values] result = _lib.skiplist_keys_values(list_converted, values_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_app_tinst_transfn(state: Annotated[_ffi.CData, 'Temporal *'], inst: Annotated[_ffi.CData, 'const TInstant *'], interp: InterpolationType, maxdist: float, maxt: Annotated[_ffi.CData, 'const Interval *']) -> Annotated[_ffi.CData, 'Temporal *']: - state_converted = _ffi.cast('Temporal *', state) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) +def temporal_app_tinst_transfn( + state: Annotated[_ffi.CData, "Temporal *"], + inst: Annotated[_ffi.CData, "const TInstant *"], + interp: InterpolationType, + maxdist: float, + maxt: Annotated[_ffi.CData, "const Interval *"], +) -> Annotated[_ffi.CData, "Temporal *"]: + state_converted = _ffi.cast("Temporal *", state) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("const Interval *", maxt) result = _lib.temporal_app_tinst_transfn(state_converted, inst_converted, interp, maxdist, maxt_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_app_tseq_transfn(state: Annotated[_ffi.CData, 'Temporal *'], seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'Temporal *']: - state_converted = _ffi.cast('Temporal *', state) - seq_converted = _ffi.cast('const TSequence *', seq) +def temporal_app_tseq_transfn( + state: Annotated[_ffi.CData, "Temporal *"], seq: Annotated[_ffi.CData, "const TSequence *"] +) -> Annotated[_ffi.CData, "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 span_bins(s: Annotated[_ffi.CData, 'const Span *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - s_converted = _ffi.cast('const Span *', s) - size_converted = _ffi.cast('Datum', size) - origin_converted = _ffi.cast('Datum', origin) - count = _ffi.new('int *') +def span_bins( + s: Annotated[_ffi.CData, "const Span *"], + size: Annotated[_ffi.CData, "Datum"], + origin: Annotated[_ffi.CData, "Datum"], +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + s_converted = _ffi.cast("const Span *", s) + size_converted = _ffi.cast("Datum", size) + origin_converted = _ffi.cast("Datum", origin) + count = _ffi.new("int *") result = _lib.span_bins(s_converted, size_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def spanset_bins(ss: Annotated[_ffi.CData, 'const SpanSet *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const SpanSet *', ss) - size_converted = _ffi.cast('Datum', size) - origin_converted = _ffi.cast('Datum', origin) - count = _ffi.new('int *') +def spanset_bins( + ss: Annotated[_ffi.CData, "const SpanSet *"], + size: Annotated[_ffi.CData, "Datum"], + origin: Annotated[_ffi.CData, "Datum"], +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const SpanSet *", ss) + size_converted = _ffi.cast("Datum", size) + origin_converted = _ffi.cast("Datum", origin) + count = _ffi.new("int *") result = _lib.spanset_bins(ss_converted, size_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_value_bins(temp: Annotated[_ffi.CData, 'const Temporal *'], size: Annotated[_ffi.CData, 'Datum'], origin: Annotated[_ffi.CData, 'Datum']) -> tuple[Annotated[_ffi.CData, 'Span *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - size_converted = _ffi.cast('Datum', size) - origin_converted = _ffi.cast('Datum', origin) - count = _ffi.new('int *') +def tnumber_value_bins( + temp: Annotated[_ffi.CData, "const Temporal *"], + size: Annotated[_ffi.CData, "Datum"], + origin: Annotated[_ffi.CData, "Datum"], +) -> tuple[Annotated[_ffi.CData, "Span *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + size_converted = _ffi.cast("Datum", size) + origin_converted = _ffi.cast("Datum", origin) + count = _ffi.new("int *") result = _lib.tnumber_value_bins(temp_converted, size_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_value_time_boxes(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int) -> tuple[Annotated[_ffi.CData, 'TBox *'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - vsize_converted = _ffi.cast('Datum', vsize) - duration_converted = _ffi.cast('const Interval *', duration) - vorigin_converted = _ffi.cast('Datum', vorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') - result = _lib.tnumber_value_time_boxes(temp_converted, vsize_converted, duration_converted, vorigin_converted, torigin_converted, count) +def tnumber_value_time_boxes( + temp: Annotated[_ffi.CData, "const Temporal *"], + vsize: Annotated[_ffi.CData, "Datum"], + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: Annotated[_ffi.CData, "Datum"], + torigin: int, +) -> tuple[Annotated[_ffi.CData, "TBox *"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + vsize_converted = _ffi.cast("Datum", vsize) + duration_converted = _ffi.cast("const Interval *", duration) + vorigin_converted = _ffi.cast("Datum", vorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") + result = _lib.tnumber_value_time_boxes( + temp_converted, vsize_converted, duration_converted, vorigin_converted, torigin_converted, count + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_value_split(temp: Annotated[_ffi.CData, 'const Temporal *'], vsize: Annotated[_ffi.CData, 'Datum'], vorigin: Annotated[_ffi.CData, 'Datum'], bins: Annotated[list, 'Datum **']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - vsize_converted = _ffi.cast('Datum', vsize) - vorigin_converted = _ffi.cast('Datum', vorigin) - bins_converted = [_ffi.cast('Datum *', x) for x in bins] - count = _ffi.new('int *') +def tnumber_value_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + vsize: Annotated[_ffi.CData, "Datum"], + vorigin: Annotated[_ffi.CData, "Datum"], + bins: Annotated[list, "Datum **"], +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + vsize_converted = _ffi.cast("Datum", vsize) + vorigin_converted = _ffi.cast("Datum", vorigin) + bins_converted = [_ffi.cast("Datum *", x) for x in bins] + count = _ffi.new("int *") result = _lib.tnumber_value_split(temp_converted, vsize_converted, vorigin_converted, bins_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tbox_get_value_time_tile(value: Annotated[_ffi.CData, 'Datum'], t: int, vsize: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int, basetype: Annotated[_ffi.CData, 'meosType'], spantype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'TBox *']: - value_converted = _ffi.cast('Datum', value) - t_converted = _ffi.cast('TimestampTz', t) - vsize_converted = _ffi.cast('Datum', vsize) - duration_converted = _ffi.cast('const Interval *', duration) - vorigin_converted = _ffi.cast('Datum', vorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - basetype_converted = _ffi.cast('meosType', basetype) - spantype_converted = _ffi.cast('meosType', spantype) - result = _lib.tbox_get_value_time_tile(value_converted, t_converted, vsize_converted, duration_converted, vorigin_converted, torigin_converted, basetype_converted, spantype_converted) +def tbox_get_value_time_tile( + value: Annotated[_ffi.CData, "Datum"], + t: int, + vsize: Annotated[_ffi.CData, "Datum"], + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: Annotated[_ffi.CData, "Datum"], + torigin: int, + basetype: Annotated[_ffi.CData, "meosType"], + spantype: Annotated[_ffi.CData, "meosType"], +) -> Annotated[_ffi.CData, "TBox *"]: + value_converted = _ffi.cast("Datum", value) + t_converted = _ffi.cast("TimestampTz", t) + vsize_converted = _ffi.cast("Datum", vsize) + duration_converted = _ffi.cast("const Interval *", duration) + vorigin_converted = _ffi.cast("Datum", vorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + basetype_converted = _ffi.cast("meosType", basetype) + spantype_converted = _ffi.cast("meosType", spantype) + result = _lib.tbox_get_value_time_tile( + value_converted, + t_converted, + vsize_converted, + duration_converted, + vorigin_converted, + torigin_converted, + basetype_converted, + spantype_converted, + ) _check_error() return result if result != _ffi.NULL else None -def tnumber_value_time_split(temp: Annotated[_ffi.CData, 'const Temporal *'], size: Annotated[_ffi.CData, 'Datum'], duration: Annotated[_ffi.CData, 'const Interval *'], vorigin: Annotated[_ffi.CData, 'Datum'], torigin: int, value_bins: Annotated[list, 'Datum **'], time_bins: Annotated[list, 'TimestampTz **']) -> tuple[Annotated[_ffi.CData, 'Temporal **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - size_converted = _ffi.cast('Datum', size) - duration_converted = _ffi.cast('const Interval *', duration) - vorigin_converted = _ffi.cast('Datum', vorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - value_bins_converted = [_ffi.cast('Datum *', x) for x in value_bins] - time_bins_converted = [_ffi.cast('TimestampTz *', x) for x in time_bins] - count = _ffi.new('int *') - result = _lib.tnumber_value_time_split(temp_converted, size_converted, duration_converted, vorigin_converted, torigin_converted, value_bins_converted, time_bins_converted, count) +def tnumber_value_time_split( + temp: Annotated[_ffi.CData, "const Temporal *"], + size: Annotated[_ffi.CData, "Datum"], + duration: Annotated[_ffi.CData, "const Interval *"], + vorigin: Annotated[_ffi.CData, "Datum"], + torigin: int, + value_bins: Annotated[list, "Datum **"], + time_bins: Annotated[list, "TimestampTz **"], +) -> tuple[Annotated[_ffi.CData, "Temporal **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + size_converted = _ffi.cast("Datum", size) + duration_converted = _ffi.cast("const Interval *", duration) + vorigin_converted = _ffi.cast("Datum", vorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + value_bins_converted = [_ffi.cast("Datum *", x) for x in value_bins] + time_bins_converted = [_ffi.cast("TimestampTz *", x) for x in time_bins] + count = _ffi.new("int *") + result = _lib.tnumber_value_time_split( + temp_converted, + size_converted, + duration_converted, + vorigin_converted, + torigin_converted, + value_bins_converted, + time_bins_converted, + count, + ) _check_error() return result if result != _ffi.NULL else None, count[0] -def proj_get_context() -> Annotated[_ffi.CData, 'PJ_CONTEXT *']: +def proj_get_context() -> Annotated[_ffi.CData, "PJ_CONTEXT *"]: result = _lib.proj_get_context() _check_error() return result if result != _ffi.NULL else None -def datum_geo_round(value: Annotated[_ffi.CData, 'Datum'], size: Annotated[_ffi.CData, 'Datum']) -> Annotated[_ffi.CData, 'Datum']: - value_converted = _ffi.cast('Datum', value) - size_converted = _ffi.cast('Datum', size) +def datum_geo_round( + value: Annotated[_ffi.CData, "Datum"], size: Annotated[_ffi.CData, "Datum"] +) -> Annotated[_ffi.CData, "Datum"]: + value_converted = _ffi.cast("Datum", value) + size_converted = _ffi.cast("Datum", size) result = _lib.datum_geo_round(value_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def point_round(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], maxdd: int) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def point_round(gs: Annotated[_ffi.CData, "const GSERIALIZED *"], maxdd: int) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.point_round(gs_converted, maxdd) _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: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - srid_converted = _ffi.cast('int32', srid) - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('STBox *', box) +def stbox_set( + hasx: bool, + hasz: bool, + geodetic: bool, + srid: int, + xmin: float, + xmax: float, + ymin: float, + ymax: float, + zmin: float, + zmax: float, + s: Annotated[_ffi.CData, "const Span *"], + box: Annotated[_ffi.CData, "STBox *"], +) -> Annotated[None, "void"]: + 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 gbox_set_stbox(box: Annotated[_ffi.CData, 'const GBOX *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[_ffi.CData, 'STBox *']: - box_converted = _ffi.cast('const GBOX *', box) - srid_converted = _ffi.cast('int32_t', srid) - out_result = _ffi.new('STBox *') +def gbox_set_stbox( + box: Annotated[_ffi.CData, "const GBOX *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[_ffi.CData, "STBox *"]: + box_converted = _ffi.cast("const GBOX *", box) + srid_converted = _ffi.cast("int32_t", srid) + out_result = _ffi.new("STBox *") _lib.gbox_set_stbox(box_converted, srid_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 geo_set_stbox(gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[bool, 'bool']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - box_converted = _ffi.cast('STBox *', box) +def geo_set_stbox( + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const Datum *'], count: int, box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - values_converted = _ffi.cast('const Datum *', values) - box_converted = _ffi.cast('STBox *', box) +def geoarr_set_stbox( + values: Annotated[_ffi.CData, "const Datum *"], count: int, box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + 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 spatial_set_stbox(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - box_converted = _ffi.cast('STBox *', box) +def spatial_set_stbox( + d: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], + box: Annotated[_ffi.CData, "STBox *"], +) -> Annotated[bool, "bool"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + box_converted = _ffi.cast("STBox *", box) result = _lib.spatial_set_stbox(d_converted, basetype_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_set_stbox(set: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - set_converted = _ffi.cast('const Set *', set) - box_converted = _ffi.cast('STBox *', box) +def spatialset_set_stbox( + set: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + set_converted = _ffi.cast("const Set *", set) + box_converted = _ffi.cast("STBox *", box) _lib.spatialset_set_stbox(set_converted, box_converted) _check_error() -def stbox_set_box3d(box: Annotated[_ffi.CData, 'const STBox *'], box3d: Annotated[_ffi.CData, 'BOX3D *']) -> Annotated[None, 'void']: - box_converted = _ffi.cast('const STBox *', box) - box3d_converted = _ffi.cast('BOX3D *', box3d) +def stbox_set_box3d( + box: Annotated[_ffi.CData, "const STBox *"], box3d: Annotated[_ffi.CData, "BOX3D *"] +) -> Annotated[None, "void"]: + 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: Annotated[_ffi.CData, 'const STBox *'], gbox: Annotated[_ffi.CData, 'GBOX *']) -> Annotated[None, 'void']: - box_converted = _ffi.cast('const STBox *', box) - gbox_converted = _ffi.cast('GBOX *', gbox) +def stbox_set_gbox( + box: Annotated[_ffi.CData, "const STBox *"], gbox: Annotated[_ffi.CData, "GBOX *"] +) -> Annotated[None, "void"]: + box_converted = _ffi.cast("const STBox *", box) + gbox_converted = _ffi.cast("GBOX *", gbox) _lib.stbox_set_gbox(box_converted, gbox_converted) _check_error() -def tstzset_set_stbox(s: Annotated[_ffi.CData, 'const Set *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('STBox *', box) +def tstzset_set_stbox( + s: Annotated[_ffi.CData, "const Set *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + s_converted = _ffi.cast("const Set *", s) + box_converted = _ffi.cast("STBox *", box) _lib.tstzset_set_stbox(s_converted, box_converted) _check_error() -def tstzspan_set_stbox(s: Annotated[_ffi.CData, 'const Span *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('STBox *', box) +def tstzspan_set_stbox( + s: Annotated[_ffi.CData, "const Span *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + s_converted = _ffi.cast("const Span *", s) + box_converted = _ffi.cast("STBox *", box) _lib.tstzspan_set_stbox(s_converted, box_converted) _check_error() -def tstzspanset_set_stbox(s: Annotated[_ffi.CData, 'const SpanSet *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - s_converted = _ffi.cast('const SpanSet *', s) - box_converted = _ffi.cast('STBox *', box) +def tstzspanset_set_stbox( + s: Annotated[_ffi.CData, "const SpanSet *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + s_converted = _ffi.cast("const SpanSet *", s) + box_converted = _ffi.cast("STBox *", box) _lib.tstzspanset_set_stbox(s_converted, box_converted) _check_error() -def stbox_expand(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('STBox *', box2) +def stbox_expand( + box1: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("STBox *", box2) _lib.stbox_expand(box1_converted, box2_converted) _check_error() -def inter_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, '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: Annotated[_ffi.CData, "const STBox *"], box2: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[_ffi.CData, "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: @@ -17045,842 +19660,970 @@ def inter_stbox_stbox(box1: Annotated[_ffi.CData, 'const STBox *'], box2: Annota return None -def stbox_geo(box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - box_converted = _ffi.cast('const STBox *', box) +def stbox_geo(box: Annotated[_ffi.CData, "const STBox *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_geo(box_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tgeogpointinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tgeogpointseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tgeogpointseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tgeogpointseqset_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tgeompointinst_in(string: str) -> Annotated[_ffi.CData, "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_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tgeompointseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tgeompointseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tgeompointseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") result = _lib.tgeompointseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeographyinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tgeographyinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: + string_converted = string.encode("utf-8") result = _lib.tgeographyinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeographyseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tgeographyseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tgeographyseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeographyseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tgeographyseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") result = _lib.tgeographyseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometryinst_in(string: str) -> Annotated[_ffi.CData, 'TInstant *']: - string_converted = string.encode('utf-8') +def tgeometryinst_in(string: str) -> Annotated[_ffi.CData, "TInstant *"]: + string_converted = string.encode("utf-8") result = _lib.tgeometryinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeometryseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, 'TSequence *']: - string_converted = string.encode('utf-8') +def tgeometryseq_in(string: str, interp: InterpolationType) -> Annotated[_ffi.CData, "TSequence *"]: + string_converted = string.encode("utf-8") result = _lib.tgeometryseq_in(string_converted, interp) _check_error() return result if result != _ffi.NULL else None -def tgeometryseqset_in(string: str) -> Annotated[_ffi.CData, 'TSequenceSet *']: - string_converted = string.encode('utf-8') +def tgeometryseqset_in(string: str) -> Annotated[_ffi.CData, "TSequenceSet *"]: + string_converted = string.encode("utf-8") result = _lib.tgeometryseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_set_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('STBox *', box) +def tspatial_set_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("STBox *", box) _lib.tspatial_set_stbox(temp_converted, box_converted) _check_error() -def tgeoinst_set_stbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('STBox *', box) +def tgeoinst_set_stbox( + inst: Annotated[_ffi.CData, "const TInstant *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + inst_converted = _ffi.cast("const TInstant *", inst) + box_converted = _ffi.cast("STBox *", box) _lib.tgeoinst_set_stbox(inst_converted, box_converted) _check_error() -def tspatialseq_set_stbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('STBox *', box) +def tspatialseq_set_stbox( + seq: Annotated[_ffi.CData, "const TSequence *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("STBox *", box) _lib.tspatialseq_set_stbox(seq_converted, box_converted) _check_error() -def tspatialseqset_set_stbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'STBox *']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('STBox *', box) +def tspatialseqset_set_stbox( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], box: Annotated[_ffi.CData, "STBox *"] +) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("STBox *", box) _lib.tspatialseqset_set_stbox(ss_converted, box_converted) _check_error() -def tgeo_restrict_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tgeo_restrict_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], + atfunc: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tgeo_restrict_geom(temp_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeo_restrict_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tgeo_restrict_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], + box: Annotated[_ffi.CData, "const STBox *"], + border_inc: bool, + atfunc: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeo_restrict_stbox(temp_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_restrict_geom(inst: Annotated[_ffi.CData, 'const TInstant *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tgeoinst_restrict_geom( + inst: Annotated[_ffi.CData, "const TInstant *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], + atfunc: bool, +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tgeoinst_restrict_geom(inst_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoinst_restrict_stbox(inst: Annotated[_ffi.CData, 'const TInstant *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('const STBox *', box) +def tgeoinst_restrict_stbox( + inst: Annotated[_ffi.CData, "const TInstant *"], + box: Annotated[_ffi.CData, "const STBox *"], + border_inc: bool, + atfunc: bool, +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeoinst_restrict_stbox(inst_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_restrict_geom(seq: Annotated[_ffi.CData, 'const TSequence *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tgeoseq_restrict_geom( + seq: Annotated[_ffi.CData, "const TSequence *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], + atfunc: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tgeoseq_restrict_geom(seq_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_restrict_stbox(seq: Annotated[_ffi.CData, 'const TSequence *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('const STBox *', box) +def tgeoseq_restrict_stbox( + seq: Annotated[_ffi.CData, "const TSequence *"], + box: Annotated[_ffi.CData, "const STBox *"], + border_inc: bool, + atfunc: bool, +) -> Annotated[_ffi.CData, "Temporal *"]: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeoseq_restrict_stbox(seq_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_restrict_geom(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *'], zspan: Annotated[_ffi.CData, 'const Span *'], atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) +def tgeoseqset_restrict_geom( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], + gs: Annotated[_ffi.CData, "const GSERIALIZED *"], + zspan: Annotated[_ffi.CData, "const Span *"], + atfunc: bool, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) result = _lib.tgeoseqset_restrict_geom(ss_converted, gs_converted, zspan_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tgeoseqset_restrict_stbox(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool, atfunc: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('const STBox *', box) +def tgeoseqset_restrict_stbox( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], + box: Annotated[_ffi.CData, "const STBox *"], + border_inc: bool, + atfunc: bool, +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tgeoseqset_restrict_stbox(ss_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def spatial_srid(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType']) -> Annotated[_ffi.CData, 'int32_t']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) +def spatial_srid( + d: Annotated[_ffi.CData, "Datum"], basetype: Annotated[_ffi.CData, "meosType"] +) -> Annotated[_ffi.CData, "int32_t"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) result = _lib.spatial_srid(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_set_srid(d: Annotated[_ffi.CData, 'Datum'], basetype: Annotated[_ffi.CData, 'meosType'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[bool, 'bool']: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - srid_converted = _ffi.cast('int32_t', srid) +def spatial_set_srid( + d: Annotated[_ffi.CData, "Datum"], + basetype: Annotated[_ffi.CData, "meosType"], + srid: Annotated[_ffi.CData, "int32_t"], +) -> Annotated[bool, "bool"]: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + srid_converted = _ffi.cast("int32_t", srid) result = _lib.spatial_set_srid(d_converted, basetype_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tspatialinst_srid(inst: Annotated[_ffi.CData, 'const TInstant *']) -> Annotated[int, 'int']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tspatialinst_srid(inst: Annotated[_ffi.CData, "const TInstant *"]) -> Annotated[int, "int"]: + inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tspatialinst_srid(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_azimuth(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_azimuth(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *'], prevlength: float) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_cumulative_length( + seq: Annotated[_ffi.CData, "const TSequence *"], prevlength: float +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[bool, 'bool']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_is_simple(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[float, 'double']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_length(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[float, "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_linear_trajectory(seq: Annotated[_ffi.CData, 'const TSequence *'], unary_union: bool) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_linear_trajectory( + seq: Annotated[_ffi.CData, "const TSequence *"], unary_union: bool +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tpointseq_linear_trajectory(seq_converted, unary_union) _check_error() return result if result != _ffi.NULL else None -def tgeoseq_stboxes(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tgeoseq_stboxes( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") result = _lib.tgeoseq_stboxes(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeoseq_split_n_stboxes(seq: Annotated[_ffi.CData, 'const TSequence *'], max_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tgeoseq_split_n_stboxes( + seq: Annotated[_ffi.CData, "const TSequence *"], max_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") result = _lib.tgeoseq_split_n_stboxes(seq_converted, max_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpointseqset_azimuth(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tpointseqset_azimuth(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tpointseqset_cumulative_length( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[bool, 'bool']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tpointseqset_is_simple(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[bool, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[float, 'double']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tpointseqset_length(ss: Annotated[_ffi.CData, "const TSequenceSet *"]) -> Annotated[float, "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 tgeoseqset_stboxes(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tgeoseqset_stboxes( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") result = _lib.tgeoseqset_stboxes(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tgeoseqset_split_n_stboxes(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], max_count: int) -> tuple[Annotated[_ffi.CData, 'STBox *'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tgeoseqset_split_n_stboxes( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], max_count: int +) -> tuple[Annotated[_ffi.CData, "STBox *"], Annotated[_ffi.CData, "int"]]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") result = _lib.tgeoseqset_split_n_stboxes(ss_converted, max_count, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpoint_get_coord(temp: Annotated[_ffi.CData, 'const Temporal *'], coord: int) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_get_coord( + temp: Annotated[_ffi.CData, "const Temporal *"], coord: int +) -> Annotated[_ffi.CData, "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 tgeominst_tgeoginst(inst: Annotated[_ffi.CData, 'const TInstant *'], oper: bool) -> Annotated[_ffi.CData, 'TInstant *']: - inst_converted = _ffi.cast('const TInstant *', inst) +def tgeominst_tgeoginst( + inst: Annotated[_ffi.CData, "const TInstant *"], oper: bool +) -> Annotated[_ffi.CData, "TInstant *"]: + inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tgeominst_tgeoginst(inst_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeomseq_tgeogseq(seq: Annotated[_ffi.CData, 'const TSequence *'], oper: bool) -> Annotated[_ffi.CData, 'TSequence *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tgeomseq_tgeogseq( + seq: Annotated[_ffi.CData, "const TSequence *"], oper: bool +) -> Annotated[_ffi.CData, "TSequence *"]: + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.tgeomseq_tgeogseq(seq_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeomseqset_tgeogseqset(ss: Annotated[_ffi.CData, 'const TSequenceSet *'], oper: bool) -> Annotated[_ffi.CData, 'TSequenceSet *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tgeomseqset_tgeogseqset( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], oper: bool +) -> Annotated[_ffi.CData, "TSequenceSet *"]: + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tgeomseqset_tgeogseqset(ss_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeom_tgeog(temp: Annotated[_ffi.CData, 'const Temporal *'], oper: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeom_tgeog(temp: Annotated[_ffi.CData, "const Temporal *"], oper: bool) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeom_tgeog(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeo_tpoint(temp: Annotated[_ffi.CData, 'const Temporal *'], oper: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeo_tpoint(temp: Annotated[_ffi.CData, "const Temporal *"], oper: bool) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeo_tpoint(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tspatialinst_set_srid(inst: Annotated[_ffi.CData, 'TInstant *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: - inst_converted = _ffi.cast('TInstant *', inst) - srid_converted = _ffi.cast('int32_t', srid) +def tspatialinst_set_srid( + inst: Annotated[_ffi.CData, "TInstant *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[None, "void"]: + inst_converted = _ffi.cast("TInstant *", inst) + srid_converted = _ffi.cast("int32_t", srid) _lib.tspatialinst_set_srid(inst_converted, srid_converted) _check_error() -def tpointseq_make_simple(seq: Annotated[_ffi.CData, 'const TSequence *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') +def tpointseq_make_simple( + seq: Annotated[_ffi.CData, "const TSequence *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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 tspatialseq_set_srid(seq: Annotated[_ffi.CData, 'TSequence *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: - seq_converted = _ffi.cast('TSequence *', seq) - srid_converted = _ffi.cast('int32_t', srid) +def tspatialseq_set_srid( + seq: Annotated[_ffi.CData, "TSequence *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[None, "void"]: + seq_converted = _ffi.cast("TSequence *", seq) + srid_converted = _ffi.cast("int32_t", srid) _lib.tspatialseq_set_srid(seq_converted, srid_converted) _check_error() -def tpointseqset_make_simple(ss: Annotated[_ffi.CData, 'const TSequenceSet *']) -> tuple[Annotated[_ffi.CData, 'TSequence **'], Annotated[_ffi.CData, 'int']]: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tpointseqset_make_simple( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> tuple[Annotated[_ffi.CData, "TSequence **"], Annotated[_ffi.CData, "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 tspatialseqset_set_srid(ss: Annotated[_ffi.CData, 'TSequenceSet *'], srid: Annotated[_ffi.CData, 'int32_t']) -> Annotated[None, 'void']: - ss_converted = _ffi.cast('TSequenceSet *', ss) - srid_converted = _ffi.cast('int32_t', srid) +def tspatialseqset_set_srid( + ss: Annotated[_ffi.CData, "TSequenceSet *"], srid: Annotated[_ffi.CData, "int32_t"] +) -> Annotated[None, "void"]: + ss_converted = _ffi.cast("TSequenceSet *", ss) + srid_converted = _ffi.cast("int32_t", srid) _lib.tspatialseqset_set_srid(ss_converted, srid_converted) _check_error() -def tpointseq_twcentroid(seq: Annotated[_ffi.CData, 'const TSequence *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - seq_converted = _ffi.cast('const TSequence *', seq) +def tpointseq_twcentroid(seq: Annotated[_ffi.CData, "const TSequence *"]) -> Annotated[_ffi.CData, "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: Annotated[_ffi.CData, 'const TSequenceSet *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tpointseqset_twcentroid( + ss: Annotated[_ffi.CData, "const TSequenceSet *"], +) -> Annotated[_ffi.CData, "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 npoint_as_ewkt(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_as_ewkt(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_as_ewkt(np_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 npoint_as_hexwkb(np: Annotated[_ffi.CData, 'const Npoint *'], variant: int) -> tuple[Annotated[str, 'char *'], Annotated[_ffi.CData, 'size_t *']]: - np_converted = _ffi.cast('const Npoint *', np) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def npoint_as_hexwkb( + np: Annotated[_ffi.CData, "const Npoint *"], variant: int +) -> tuple[Annotated[str, "char *"], Annotated[_ffi.CData, "size_t *"]]: + np_converted = _ffi.cast("const Npoint *", np) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.npoint_as_hexwkb(np_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 npoint_as_text(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_as_text(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_as_text(np_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 npoint_as_wkb(np: Annotated[_ffi.CData, 'const Npoint *'], variant: int) -> tuple[Annotated[_ffi.CData, 'uint8_t *'], Annotated[_ffi.CData, 'size_t *']]: - np_converted = _ffi.cast('const Npoint *', np) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def npoint_as_wkb( + np: Annotated[_ffi.CData, "const Npoint *"], variant: int +) -> tuple[Annotated[_ffi.CData, "uint8_t *"], Annotated[_ffi.CData, "size_t *"]]: + np_converted = _ffi.cast("const Npoint *", np) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.npoint_as_wkb(np_converted, variant_converted, size_out) _check_error() return result if result != _ffi.NULL else None, size_out[0] -def npoint_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, 'Npoint *']: - hexwkb_converted = hexwkb.encode('utf-8') +def npoint_from_hexwkb(hexwkb: str) -> Annotated[_ffi.CData, "Npoint *"]: + hexwkb_converted = hexwkb.encode("utf-8") result = _lib.npoint_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_from_wkb(wkb: Annotated[_ffi.CData, 'const uint8_t *'], size: Annotated[_ffi.CData, 'size_t']) -> Annotated[_ffi.CData, 'Npoint *']: - wkb_converted = _ffi.cast('const uint8_t *', wkb) - size_converted = _ffi.cast('size_t', size) +def npoint_from_wkb( + wkb: Annotated[_ffi.CData, "const uint8_t *"], size: Annotated[_ffi.CData, "size_t"] +) -> Annotated[_ffi.CData, "Npoint *"]: + wkb_converted = _ffi.cast("const uint8_t *", wkb) + size_converted = _ffi.cast("size_t", size) result = _lib.npoint_from_wkb(wkb_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_in(string: str) -> Annotated[_ffi.CData, 'Npoint *']: - string_converted = string.encode('utf-8') +def npoint_in(string: str) -> Annotated[_ffi.CData, "Npoint *"]: + string_converted = string.encode("utf-8") result = _lib.npoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_out(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[str, 'char *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_out(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[str, "char *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_out(np_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 nsegment_in(string: str) -> Annotated[_ffi.CData, 'Nsegment *']: - string_converted = string.encode('utf-8') +def nsegment_in(string: str) -> Annotated[_ffi.CData, "Nsegment *"]: + string_converted = string.encode("utf-8") result = _lib.nsegment_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_out(ns: Annotated[_ffi.CData, 'const Nsegment *'], maxdd: int) -> Annotated[str, 'char *']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_out(ns: Annotated[_ffi.CData, "const Nsegment *"], maxdd: int) -> Annotated[str, "char *"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_out(ns_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 npoint_make(rid: int, pos: float) -> Annotated[_ffi.CData, 'Npoint *']: - rid_converted = _ffi.cast('int64', rid) +def npoint_make(rid: int, pos: float) -> Annotated[_ffi.CData, "Npoint *"]: + rid_converted = _ffi.cast("int64", rid) result = _lib.npoint_make(rid_converted, pos) _check_error() return result if result != _ffi.NULL else None -def nsegment_make(rid: int, pos1: float, pos2: float) -> Annotated[_ffi.CData, 'Nsegment *']: - rid_converted = _ffi.cast('int64', rid) +def nsegment_make(rid: int, pos1: float, pos2: float) -> Annotated[_ffi.CData, "Nsegment *"]: + rid_converted = _ffi.cast("int64", rid) result = _lib.nsegment_make(rid_converted, pos1, pos2) _check_error() return result if result != _ffi.NULL else None -def geompoint_to_npoint(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Npoint *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geompoint_to_npoint(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Npoint *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geompoint_to_npoint(gs_converted) _check_error() return result if result != _ffi.NULL else None -def geom_to_nsegment(gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Nsegment *']: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def geom_to_nsegment(gs: Annotated[_ffi.CData, "const GSERIALIZED *"]) -> Annotated[_ffi.CData, "Nsegment *"]: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.geom_to_nsegment(gs_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_geompoint(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_to_geompoint(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_to_geompoint(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_nsegment(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Nsegment *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_to_nsegment(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "Nsegment *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_to_nsegment(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'STBox *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_to_stbox(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "STBox *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_to_stbox(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_to_geom(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_to_geom(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_to_geom(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_to_stbox(np: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'STBox *']: - np_converted = _ffi.cast('const Nsegment *', np) +def nsegment_to_stbox(np: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "STBox *"]: + np_converted = _ffi.cast("const Nsegment *", np) result = _lib.nsegment_to_stbox(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_hash(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'uint32']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_hash(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[int, "uint32"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_hash(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_hash_extended(np: Annotated[_ffi.CData, 'const Npoint *'], seed: int) -> Annotated[int, 'uint64']: - np_converted = _ffi.cast('const Npoint *', np) - seed_converted = _ffi.cast('uint64', seed) +def npoint_hash_extended(np: Annotated[_ffi.CData, "const Npoint *"], seed: int) -> Annotated[int, "uint64"]: + np_converted = _ffi.cast("const Npoint *", np) + seed_converted = _ffi.cast("uint64", seed) result = _lib.npoint_hash_extended(np_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_position(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[float, 'double']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_position(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[float, "double"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_position(np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_route(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int64']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_route(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[int, "int64"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_route(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_end_position(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[float, 'double']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_end_position(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[float, "double"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_end_position(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_route(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[int, 'int64']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_route(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[int, "int64"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_route(ns_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_start_position(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[float, 'double']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_start_position(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[float, "double"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_start_position(ns_converted) _check_error() return result if result != _ffi.NULL else None -def route_exists(rid: int) -> Annotated[bool, 'bool']: - rid_converted = _ffi.cast('int64', rid) +def route_exists(rid: int) -> Annotated[bool, "bool"]: + rid_converted = _ffi.cast("int64", rid) result = _lib.route_exists(rid_converted) _check_error() return result if result != _ffi.NULL else None -def route_geom(rid: int) -> Annotated[_ffi.CData, 'const GSERIALIZED *']: - rid_converted = _ffi.cast('int64', rid) +def route_geom(rid: int) -> Annotated[_ffi.CData, "const GSERIALIZED *"]: + rid_converted = _ffi.cast("int64", rid) result = _lib.route_geom(rid_converted) _check_error() return result if result != _ffi.NULL else None -def route_length(rid: int) -> Annotated[float, 'double']: - rid_converted = _ffi.cast('int64', rid) +def route_length(rid: int) -> Annotated[float, "double"]: + rid_converted = _ffi.cast("int64", rid) result = _lib.route_length(rid_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_round(np: Annotated[_ffi.CData, 'const Npoint *'], maxdd: int) -> Annotated[_ffi.CData, 'Npoint *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_round(np: Annotated[_ffi.CData, "const Npoint *"], maxdd: int) -> Annotated[_ffi.CData, "Npoint *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_round(np_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def nsegment_round(ns: Annotated[_ffi.CData, 'const Nsegment *'], maxdd: int) -> Annotated[_ffi.CData, 'Nsegment *']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_round(ns: Annotated[_ffi.CData, "const Nsegment *"], maxdd: int) -> Annotated[_ffi.CData, "Nsegment *"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_round(ns_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def get_srid_ways() -> Annotated[_ffi.CData, 'int32_t']: +def get_srid_ways() -> Annotated[_ffi.CData, "int32_t"]: result = _lib.get_srid_ways() _check_error() return result if result != _ffi.NULL else None -def npoint_srid(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'int32_t']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_srid(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "int32_t"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_srid(np_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_srid(ns: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[_ffi.CData, 'int32_t']: - ns_converted = _ffi.cast('const Nsegment *', ns) +def nsegment_srid(ns: Annotated[_ffi.CData, "const Nsegment *"]) -> Annotated[_ffi.CData, "int32_t"]: + ns_converted = _ffi.cast("const Nsegment *", ns) result = _lib.nsegment_srid(ns_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_timestamptz_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *'], t: int) -> Annotated[_ffi.CData, 'STBox *']: - np_converted = _ffi.cast('const Npoint *', np) - t_converted = _ffi.cast('TimestampTz', t) +def npoint_timestamptz_to_stbox( + np: Annotated[_ffi.CData, "const Npoint *"], t: int +) -> Annotated[_ffi.CData, "STBox *"]: + np_converted = _ffi.cast("const Npoint *", np) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.npoint_timestamptz_to_stbox(np_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_tstzspan_to_stbox(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Span *']) -> Annotated[_ffi.CData, 'STBox *']: - np_converted = _ffi.cast('const Npoint *', np) - s_converted = _ffi.cast('const Span *', s) +def npoint_tstzspan_to_stbox( + np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Span *"] +) -> Annotated[_ffi.CData, "STBox *"]: + np_converted = _ffi.cast("const Npoint *", np) + s_converted = _ffi.cast("const Span *", s) result = _lib.npoint_tstzspan_to_stbox(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_cmp(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_cmp( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[int, "int"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_cmp(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_eq(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_eq( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_eq(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_ge(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_ge( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_ge(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_gt(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_gt( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_gt(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_le(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_le( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_le(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_lt(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_lt( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_lt(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_ne(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_ne( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_ne(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_same(np1: Annotated[_ffi.CData, 'const Npoint *'], np2: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - np1_converted = _ffi.cast('const Npoint *', np1) - np2_converted = _ffi.cast('const Npoint *', np2) +def npoint_same( + np1: Annotated[_ffi.CData, "const Npoint *"], np2: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + np1_converted = _ffi.cast("const Npoint *", np1) + np2_converted = _ffi.cast("const Npoint *", np2) result = _lib.npoint_same(np1_converted, np2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_cmp(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[int, 'int']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_cmp( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[int, "int"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_cmp(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_eq(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_eq( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_eq(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_ge(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_ge( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_ge(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_gt(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_gt( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_gt(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_le(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_le( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_le(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_lt(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_lt( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_lt(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def nsegment_ne(ns1: Annotated[_ffi.CData, 'const Nsegment *'], ns2: Annotated[_ffi.CData, 'const Nsegment *']) -> Annotated[bool, 'bool']: - ns1_converted = _ffi.cast('const Nsegment *', ns1) - ns2_converted = _ffi.cast('const Nsegment *', ns2) +def nsegment_ne( + ns1: Annotated[_ffi.CData, "const Nsegment *"], ns2: Annotated[_ffi.CData, "const Nsegment *"] +) -> Annotated[bool, "bool"]: + ns1_converted = _ffi.cast("const Nsegment *", ns1) + ns2_converted = _ffi.cast("const Nsegment *", ns2) result = _lib.nsegment_ne(ns1_converted, ns2_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_in(string: str) -> Annotated[_ffi.CData, 'Set *']: - string_converted = string.encode('utf-8') +def npointset_in(string: str) -> Annotated[_ffi.CData, "Set *"]: + string_converted = string.encode("utf-8") result = _lib.npointset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_out(s: Annotated[_ffi.CData, 'const Set *'], maxdd: int) -> Annotated[str, 'char *']: - s_converted = _ffi.cast('const Set *', s) +def npointset_out(s: Annotated[_ffi.CData, "const Set *"], maxdd: int) -> Annotated[str, "char *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.npointset_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 npointset_make(values: Annotated[list, 'Npoint **'], count: int) -> Annotated[_ffi.CData, 'Set *']: - values_converted = [_ffi.cast('Npoint *', x) for x in values] +def npointset_make(values: Annotated[list, "Npoint **"], count: int) -> Annotated[_ffi.CData, "Set *"]: + values_converted = [_ffi.cast("Npoint *", x) for x in values] result = _lib.npointset_make(values_converted, count) _check_error() return result if result != _ffi.NULL else None -def npoint_to_set(np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: - np_converted = _ffi.cast('const Npoint *', np) +def npoint_to_set(np: Annotated[_ffi.CData, "const Npoint *"]) -> Annotated[_ffi.CData, "Set *"]: + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_to_set(np_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_end_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint *']: - s_converted = _ffi.cast('const Set *', s) +def npointset_end_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.npointset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_routes(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) +def npointset_routes(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.npointset_routes(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_start_value(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint *']: - s_converted = _ffi.cast('const Set *', s) +def npointset_start_value(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint *"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.npointset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def npointset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annotated[list, 'Npoint **']: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('Npoint **') +def npointset_value_n(s: Annotated[_ffi.CData, "const Set *"], n: int) -> Annotated[list, "Npoint **"]: + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("Npoint **") result = _lib.npointset_value_n(s_converted, n, out_result) _check_error() if result: @@ -17888,464 +20631,554 @@ def npointset_value_n(s: Annotated[_ffi.CData, 'const Set *'], n: int) -> Annota return None -def npointset_values(s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Npoint **']: - s_converted = _ffi.cast('const Set *', s) +def npointset_values(s: Annotated[_ffi.CData, "const Set *"]) -> Annotated[_ffi.CData, "Npoint **"]: + s_converted = _ffi.cast("const Set *", s) result = _lib.npointset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[bool, 'bool']: - np_converted = _ffi.cast('const Npoint *', np) - s_converted = _ffi.cast('const Set *', s) +def contained_npoint_set( + np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[bool, "bool"]: + np_converted = _ffi.cast("const Npoint *", np) + s_converted = _ffi.cast("const Set *", s) result = _lib.contained_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[bool, 'bool']: - s_converted = _ffi.cast('const Set *', s) - np_converted = _ffi.cast('const Npoint *', np) +def contains_set_npoint( + s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[bool, "bool"]: + s_converted = _ffi.cast("const Set *", s) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.contains_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - np_converted = _ffi.cast('const Npoint *', np) - s_converted = _ffi.cast('const Set *', s) +def intersection_npoint_set( + np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Set *"]: + np_converted = _ffi.cast("const Npoint *", np) + s_converted = _ffi.cast("const Set *", s) result = _lib.intersection_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - np_converted = _ffi.cast('const Npoint *', np) +def intersection_set_npoint( + s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.intersection_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def minus_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - np_converted = _ffi.cast('const Npoint *', np) - s_converted = _ffi.cast('const Set *', s) +def minus_npoint_set( + np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Set *"]: + np_converted = _ffi.cast("const Npoint *", np) + s_converted = _ffi.cast("const Set *", s) result = _lib.minus_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - np_converted = _ffi.cast('const Npoint *', np) +def minus_set_npoint( + s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.minus_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def npoint_union_transfn(state: Annotated[_ffi.CData, 'Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: - state_converted = _ffi.cast('Set *', state) - np_converted = _ffi.cast('const Npoint *', np) +def npoint_union_transfn( + state: Annotated[_ffi.CData, "Set *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Set *"]: + state_converted = _ffi.cast("Set *", state) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.npoint_union_transfn(state_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def union_npoint_set(np: Annotated[_ffi.CData, 'const Npoint *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Set *']: - np_converted = _ffi.cast('const Npoint *', np) - s_converted = _ffi.cast('const Set *', s) +def union_npoint_set( + np: Annotated[_ffi.CData, "const Npoint *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Set *"]: + np_converted = _ffi.cast("const Npoint *", np) + s_converted = _ffi.cast("const Set *", s) result = _lib.union_npoint_set(np_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_npoint(s: Annotated[_ffi.CData, 'const Set *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Set *']: - s_converted = _ffi.cast('const Set *', s) - np_converted = _ffi.cast('const Npoint *', np) +def union_set_npoint( + s: Annotated[_ffi.CData, "const Set *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Set *"]: + s_converted = _ffi.cast("const Set *", s) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.union_set_npoint(s_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_in(string: str) -> Annotated[_ffi.CData, 'Temporal *']: - string_converted = string.encode('utf-8') +def tnpoint_in(string: str) -> Annotated[_ffi.CData, "Temporal *"]: + string_converted = string.encode("utf-8") result = _lib.tnpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_out(temp: Annotated[_ffi.CData, 'const Temporal *'], maxdd: int) -> Annotated[str, 'char *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_out(temp: Annotated[_ffi.CData, "const Temporal *"], maxdd: int) -> Annotated[str, "char *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_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 tnpointinst_make(np: Annotated[_ffi.CData, 'const Npoint *'], t: int) -> Annotated[_ffi.CData, 'TInstant *']: - np_converted = _ffi.cast('const Npoint *', np) - t_converted = _ffi.cast('TimestampTz', t) +def tnpointinst_make(np: Annotated[_ffi.CData, "const Npoint *"], t: int) -> Annotated[_ffi.CData, "TInstant *"]: + np_converted = _ffi.cast("const Npoint *", np) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tnpointinst_make(np_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tnpoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tgeompoint_to_tnpoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tgeompoint_to_tnpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_to_tgeompoint(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_to_tgeompoint(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_cumulative_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_cumulative_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_cumulative_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_length(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_length(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_positions(temp: Annotated[_ffi.CData, 'const Temporal *']) -> tuple[Annotated[_ffi.CData, 'Nsegment **'], Annotated[_ffi.CData, 'int']]: - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tnpoint_positions( + temp: Annotated[_ffi.CData, "const Temporal *"], +) -> tuple[Annotated[_ffi.CData, "Nsegment **"], Annotated[_ffi.CData, "int"]]: + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tnpoint_positions(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnpoint_route(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int64']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_route(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[int, "int64"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_route(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_routes(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Set *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_routes(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Set *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_routes(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_speed(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_speed(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_speed(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_trajectory(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_trajectory(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_trajectory(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_twcentroid(temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) +def tnpoint_twcentroid(temp: Annotated[_ffi.CData, "const Temporal *"]) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnpoint_twcentroid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tnpoint_at_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tnpoint_at_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def tnpoint_at_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.tnpoint_at_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_npointset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def tnpoint_at_npointset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) result = _lib.tnpoint_at_npointset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_at_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tnpoint_at_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tnpoint_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_geom(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tnpoint_minus_geom( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tnpoint_minus_geom(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def tnpoint_minus_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.tnpoint_minus_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_npointset(temp: Annotated[_ffi.CData, 'const Temporal *'], s: Annotated[_ffi.CData, 'const Set *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def tnpoint_minus_npointset( + temp: Annotated[_ffi.CData, "const Temporal *"], s: Annotated[_ffi.CData, "const Set *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) result = _lib.tnpoint_minus_npointset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_minus_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *'], border_inc: bool) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tnpoint_minus_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"], border_inc: bool +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tnpoint_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def tdistance_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.tdistance_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_point(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def tdistance_tnpoint_point( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.tdistance_tnpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tdistance_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def tdistance_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.tdistance_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def nad_tnpoint_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.nad_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def nad_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.nad_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_stbox(temp: Annotated[_ffi.CData, 'const Temporal *'], box: Annotated[_ffi.CData, 'const STBox *']) -> Annotated[float, 'double']: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def nad_tnpoint_stbox( + temp: Annotated[_ffi.CData, "const Temporal *"], box: Annotated[_ffi.CData, "const STBox *"] +) -> Annotated[float, "double"]: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.nad_tnpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[float, 'double']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nad_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[float, "double"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.nad_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def nai_tnpoint_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.nai_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def nai_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "TInstant *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.nai_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'TInstant *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def nai_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "TInstant *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.nai_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_geo(temp: Annotated[_ffi.CData, 'const Temporal *'], gs: Annotated[_ffi.CData, 'const GSERIALIZED *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) +def shortestline_tnpoint_geo( + temp: Annotated[_ffi.CData, "const Temporal *"], gs: Annotated[_ffi.CData, "const GSERIALIZED *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) result = _lib.shortestline_tnpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def shortestline_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.shortestline_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[_ffi.CData, 'GSERIALIZED *']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def shortestline_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[_ffi.CData, "GSERIALIZED *"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.shortestline_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tnpoint_tcentroid_transfn(state: Annotated[_ffi.CData, 'SkipList *'], temp: Annotated[_ffi.CData, 'Temporal *']) -> Annotated[_ffi.CData, 'SkipList *']: - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('Temporal *', temp) +def tnpoint_tcentroid_transfn( + state: Annotated[_ffi.CData, "SkipList *"], temp: Annotated[_ffi.CData, "Temporal *"] +) -> Annotated[_ffi.CData, "SkipList *"]: + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("Temporal *", temp) result = _lib.tnpoint_tcentroid_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - np_converted = _ffi.cast('const Npoint *', np) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_eq_npoint_tnpoint( + np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + np_converted = _ffi.cast("const Npoint *", np) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.always_eq_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def always_eq_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.always_eq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def always_eq_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_eq_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.always_eq_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - np_converted = _ffi.cast('const Npoint *', np) - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_npoint_tnpoint( + np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + np_converted = _ffi.cast("const Npoint *", np) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.always_ne_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def always_ne_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.always_ne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def always_ne_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def always_ne_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.always_ne_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - np_converted = _ffi.cast('const Npoint *', np) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_npoint_tnpoint( + np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + np_converted = _ffi.cast("const Npoint *", np) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ever_eq_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def ever_eq_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.ever_eq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def ever_eq_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_eq_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ever_eq_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_npoint_tnpoint(np: Annotated[_ffi.CData, 'const Npoint *'], temp: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - np_converted = _ffi.cast('const Npoint *', np) - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_ne_npoint_tnpoint( + np: Annotated[_ffi.CData, "const Npoint *"], temp: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + np_converted = _ffi.cast("const Npoint *", np) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ever_ne_npoint_tnpoint(np_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[int, 'int']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def ever_ne_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[int, "int"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.ever_ne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def ever_ne_tnpoint_tnpoint(temp1: Annotated[_ffi.CData, 'const Temporal *'], temp2: Annotated[_ffi.CData, 'const Temporal *']) -> Annotated[int, 'int']: - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def ever_ne_tnpoint_tnpoint( + temp1: Annotated[_ffi.CData, "const Temporal *"], temp2: Annotated[_ffi.CData, "const Temporal *"] +) -> Annotated[int, "int"]: + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.ever_ne_tnpoint_tnpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def teq_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.teq_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tnpoint_npoint(temp: Annotated[_ffi.CData, 'const Temporal *'], np: Annotated[_ffi.CData, 'const Npoint *']) -> Annotated[_ffi.CData, 'Temporal *']: - temp_converted = _ffi.cast('const Temporal *', temp) - np_converted = _ffi.cast('const Npoint *', np) +def tne_tnpoint_npoint( + temp: Annotated[_ffi.CData, "const Temporal *"], np: Annotated[_ffi.CData, "const Npoint *"] +) -> Annotated[_ffi.CData, "Temporal *"]: + temp_converted = _ffi.cast("const Temporal *", temp) + np_converted = _ffi.cast("const Npoint *", np) result = _lib.tne_tnpoint_npoint(temp_converted, np_converted) _check_error() return result if result != _ffi.NULL else None - - From 3e5ad8ef84d5eae56fe27789f2c11e3028d032ee Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 14 May 2026 17:22:06 +0200 Subject: [PATCH 11/11] Run ruff format on __init__.py and templates/functions.py The templates use double-quoted strings; __init__.py was previously in mixed-quote form. ruff format normalises both, which the Check format CI step enforces. --- builder/templates/functions.py | 8 +- pymeos_cffi/__init__.py | 4755 ++++++++++++++++---------------- 2 files changed, 2379 insertions(+), 2384 deletions(-) diff --git a/builder/templates/functions.py b/builder/templates/functions.py index 072f49c..7a0e243 100644 --- a/builder/templates/functions.py +++ b/builder/templates/functions.py @@ -158,9 +158,7 @@ def tbox_shift_scale_float( hasshift: bool, haswidth: bool, ) -> Annotated[_ffi.CData, "TBox *"]: - return tbox_shift_scale_value( - box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth - ) + return tbox_shift_scale_value(box, float_to_datum(shift), float_to_datum(width), hasshift, haswidth) def tbox_shift_scale_int( @@ -170,9 +168,7 @@ def tbox_shift_scale_int( hasshift: bool, haswidth: bool, ) -> Annotated[_ffi.CData, "TBox *"]: - return tbox_shift_scale_value( - box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth - ) + return tbox_shift_scale_value(box, int_to_datum(shift), int_to_datum(width), hasshift, haswidth) # ----------------------------------------------------------------------------- diff --git a/pymeos_cffi/__init__.py b/pymeos_cffi/__init__.py index 10bcc8e..4ad3ce1 100644 --- a/pymeos_cffi/__init__.py +++ b/pymeos_cffi/__init__.py @@ -34,2382 +34,2381 @@ "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', - 'float_to_datum', - 'int_to_datum', - 'tbox_expand_float', - 'tbox_expand_int', - 'tbox_shift_scale_float', - 'tbox_shift_scale_int', - 'date_in', - 'date_out', - 'interval_cmp', - 'interval_in', - 'interval_out', - 'time_in', - 'time_out', - 'timestamp_in', - 'timestamp_out', - 'timestamptz_in', - 'timestamptz_out', - 'rtree_create_intspan', - 'rtree_create_bigintspan', - 'rtree_create_floatspan', - 'rtree_create_datespan', - 'rtree_create_tstzspan', - 'rtree_create_tbox', - 'rtree_create_stbox', - 'rtree_free', - 'rtree_insert', - 'rtree_search', - 'meos_errno', - 'meos_errno_set', - 'meos_errno_restore', - 'meos_errno_reset', - 'meos_finalize_projsrs', - 'meos_finalize_ways', - 'meos_set_datestyle', - 'meos_set_intervalstyle', - 'meos_get_datestyle', - 'meos_get_intervalstyle', - 'meos_set_spatial_ref_sys_csv', - 'meos_initialize', - 'meos_finalize', - 'add_date_int', - 'add_interval_interval', - 'add_timestamptz_interval', - 'bool_in', - 'bool_out', - 'cstring2text', - 'date_to_timestamp', - 'date_to_timestamptz', - 'float_exp', - 'float_ln', - 'float_log10', - 'float8_out', - 'float_round', - 'int32_cmp', - 'int64_cmp', - 'interval_make', - 'minus_date_date', - 'minus_date_int', - 'minus_timestamptz_interval', - 'minus_timestamptz_timestamptz', - 'mul_interval_double', - 'pg_date_in', - 'pg_date_out', - 'pg_interval_cmp', - 'pg_interval_in', - 'pg_interval_out', - 'pg_timestamp_in', - 'pg_timestamp_out', - 'pg_timestamptz_in', - 'pg_timestamptz_out', - 'text2cstring', - 'text_cmp', - 'text_copy', - 'text_in', - 'text_initcap', - 'text_lower', - 'text_out', - 'text_upper', - 'textcat_text_text', - 'timestamptz_shift', - 'timestamp_to_date', - 'timestamptz_to_date', - 'bigintset_in', - 'bigintset_out', - 'bigintspan_expand', - '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_expand', - 'floatspan_in', - 'floatspan_out', - 'floatspanset_in', - 'floatspanset_out', - 'intset_in', - 'intset_out', - 'intspan_expand', - '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', - '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', - 'int_to_set', - 'int_to_span', - 'int_to_spanset', - 'intset_to_floatset', - 'intspan_to_floatspan', - 'intspanset_to_floatspanset', - 'set_to_span', - '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', - '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', - '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_spanarr', - '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_timestamps', - 'tstzspanset_timestamptz_n', - 'tstzspanset_upper', - 'bigintset_shift_scale', - 'bigintspan_shift_scale', - 'bigintspanset_shift_scale', - 'dateset_shift_scale', - 'datespan_shift_scale', - 'datespanset_shift_scale', - 'floatset_ceil', - 'floatset_degrees', - 'floatset_floor', - 'floatset_radians', - 'floatset_shift_scale', - 'floatspan_ceil', - 'floatspan_degrees', - 'floatspan_floor', - 'floatspan_radians', - 'floatspan_round', - 'floatspan_shift_scale', - 'floatspanset_ceil', - 'floatspanset_floor', - 'floatspanset_degrees', - 'floatspanset_radians', - 'floatspanset_round', - 'floatspanset_shift_scale', - 'intset_shift_scale', - 'intspan_shift_scale', - 'intspanset_shift_scale', - 'tstzspan_expand', - 'set_round', - 'textcat_text_textset', - 'textcat_textset_text', - 'textset_initcap', - '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', - 'set_spans', - 'set_split_each_n_spans', - 'set_split_n_spans', - 'spanset_spans', - 'spanset_split_each_n_spans', - 'spanset_split_n_spans', - '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_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_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_int_set', - 'intersection_set_bigint', - 'intersection_set_date', - 'intersection_set_float', - '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_int_set', - 'minus_int_span', - 'minus_int_spanset', - 'minus_set_bigint', - 'minus_set_date', - 'minus_set_float', - '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_int_set', - 'union_int_span', - 'union_int_spanset', - 'union_set_bigint', - 'union_set_date', - 'union_set_float', - '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', - 'bigint_get_bin', - 'bigintspan_bins', - 'bigintspanset_bins', - 'date_get_bin', - 'datespan_bins', - 'datespanset_bins', - 'float_get_bin', - 'floatspan_bins', - 'floatspanset_bins', - 'int_get_bin', - 'intspan_bins', - 'intspanset_bins', - 'timestamptz_get_bin', - 'tstzspan_bins', - 'tstzspanset_bins', - 'tbox_as_hexwkb', - 'tbox_as_wkb', - 'tbox_from_hexwkb', - 'tbox_from_wkb', - 'tbox_in', - 'tbox_out', - 'float_timestamptz_to_tbox', - 'float_tstzspan_to_tbox', - 'int_timestamptz_to_tbox', - 'int_tstzspan_to_tbox', - 'numspan_tstzspan_to_tbox', - 'numspan_timestamptz_to_tbox', - 'tbox_copy', - 'tbox_make', - 'float_to_tbox', - 'int_to_tbox', - 'set_to_tbox', - 'span_to_tbox', - 'spanset_to_tbox', - 'tbox_to_intspan', - 'tbox_to_floatspan', - 'tbox_to_tstzspan', - 'timestamptz_to_tbox', - 'tbox_hash', - 'tbox_hash_extended', - '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', - 'tbox_expand_time', - 'tbox_round', - 'tbox_shift_scale_time', - 'tfloatbox_expand', - 'tfloatbox_shift_scale', - 'tintbox_expand', - 'tintbox_shift_scale', - 'union_tbox_tbox', - 'intersection_tbox_tbox', - 'adjacent_tbox_tbox', - 'contained_tbox_tbox', - 'contains_tbox_tbox', - 'overlaps_tbox_tbox', - 'same_tbox_tbox', - 'after_tbox_tbox', - 'before_tbox_tbox', - 'left_tbox_tbox', - 'overafter_tbox_tbox', - 'overbefore_tbox_tbox', - 'overleft_tbox_tbox', - 'overright_tbox_tbox', - 'right_tbox_tbox', - 'tbox_cmp', - 'tbox_eq', - 'tbox_ge', - 'tbox_gt', - 'tbox_le', - 'tbox_lt', - 'tbox_ne', - 'tbool_from_mfjson', - 'tbool_in', - 'tbool_out', - 'temporal_as_hexwkb', - 'temporal_as_mfjson', - 'temporal_as_wkb', - 'temporal_from_hexwkb', - 'temporal_from_wkb', - 'tfloat_from_mfjson', - 'tfloat_in', - 'tfloat_out', - 'tint_from_mfjson', - 'tint_in', - 'tint_out', - 'ttext_from_mfjson', - '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_tstzset', - 'tfloatseq_from_base_tstzspan', - 'tfloatseqset_from_base_tstzspanset', - 'tint_from_base_temp', - 'tintinst_make', - 'tintseq_from_base_tstzset', - 'tintseq_from_base_tstzspan', - 'tintseqset_from_base_tstzspanset', - 'tsequence_make', - 'tsequenceset_make', - 'tsequenceset_make_gaps', - 'ttext_from_base_temp', - 'ttextinst_make', - 'ttextseq_from_base_tstzset', - 'ttextseq_from_base_tstzspan', - 'ttextseqset_from_base_tstzspanset', - 'tbool_to_tint', - 'temporal_to_tstzspan', - 'tfloat_to_tint', - 'tint_to_tfloat', - 'tnumber_to_span', - 'tnumber_to_tbox', - 'tbool_end_value', - 'tbool_start_value', - 'tbool_value_at_timestamptz', - 'tbool_value_n', - 'tbool_values', - 'temporal_duration', - 'temporal_end_instant', - 'temporal_end_sequence', - 'temporal_end_timestamptz', - 'temporal_hash', - 'temporal_instant_n', - 'temporal_instants', - 'temporal_interp', - 'temporal_lower_inc', - 'temporal_max_instant', - 'temporal_min_instant', - 'temporal_num_instants', - 'temporal_num_sequences', - 'temporal_num_timestamps', - 'temporal_segm_duration', - 'temporal_segments', - 'temporal_sequence_n', - 'temporal_sequences', - 'temporal_start_instant', - 'temporal_start_sequence', - 'temporal_start_timestamptz', - 'temporal_stops', - 'temporal_subtype', - 'temporal_time', - 'temporal_timestamps', - 'temporal_timestamptz_n', - 'temporal_upper_inc', - 'tfloat_end_value', - 'tfloat_min_value', - 'tfloat_max_value', - 'tfloat_start_value', - 'tfloat_value_at_timestamptz', - 'tfloat_value_n', - 'tfloat_values', - 'tint_end_value', - 'tint_max_value', - 'tint_min_value', - 'tint_start_value', - 'tint_value_at_timestamptz', - 'tint_value_n', - 'tint_values', - 'tnumber_avg_value', - 'tnumber_integral', - 'tnumber_twavg', - 'tnumber_valuespans', - 'ttext_end_value', - 'ttext_max_value', - 'ttext_min_value', - 'ttext_start_value', - 'ttext_value_at_timestamptz', - 'ttext_value_n', - 'ttext_values', - 'float_degrees', - 'temparr_round', - 'temporal_round', - 'temporal_scale_time', - 'temporal_set_interp', - 'temporal_shift_scale_time', - 'temporal_shift_time', - 'temporal_to_tinstant', - 'temporal_to_tsequence', - 'temporal_to_tsequenceset', - 'tfloat_ceil', - 'tfloat_degrees', - 'tfloat_floor', - 'tfloat_radians', - '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_timestamptz', - 'temporal_delete_tstzset', - 'temporal_delete_tstzspan', - 'temporal_delete_tstzspanset', - 'temporal_insert', - 'temporal_merge', - 'temporal_merge_array', - 'temporal_update', - 'tbool_at_value', - 'tbool_minus_value', - 'temporal_after_timestamptz', - 'temporal_at_max', - 'temporal_at_min', - 'temporal_at_timestamptz', - 'temporal_at_tstzset', - 'temporal_at_tstzspan', - 'temporal_at_tstzspanset', - 'temporal_at_values', - 'temporal_before_timestamptz', - 'temporal_minus_max', - 'temporal_minus_min', - 'temporal_minus_timestamptz', - 'temporal_minus_tstzset', - 'temporal_minus_tstzspan', - 'temporal_minus_tstzspanset', - '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', - '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_tbool_bool', - 'always_eq_temporal_temporal', - 'always_eq_text_ttext', - 'always_eq_tfloat_float', - 'always_eq_tint_int', - 'always_eq_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', - 'always_ne_bool_tbool', - 'always_ne_float_tfloat', - 'always_ne_int_tint', - 'always_ne_tbool_bool', - 'always_ne_temporal_temporal', - 'always_ne_text_ttext', - 'always_ne_tfloat_float', - 'always_ne_tint_int', - 'always_ne_ttext_text', - 'ever_eq_bool_tbool', - 'ever_eq_float_tfloat', - 'ever_eq_int_tint', - 'ever_eq_tbool_bool', - 'ever_eq_temporal_temporal', - 'ever_eq_text_ttext', - 'ever_eq_tfloat_float', - 'ever_eq_tint_int', - '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_tbool_bool', - 'ever_ne_temporal_temporal', - 'ever_ne_text_ttext', - 'ever_ne_tfloat_float', - 'ever_ne_tint_int', - 'ever_ne_ttext_text', - 'teq_bool_tbool', - 'teq_float_tfloat', - 'teq_int_tint', - 'teq_tbool_bool', - 'teq_temporal_temporal', - 'teq_text_ttext', - 'teq_tfloat_float', - '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_tbool_bool', - 'tne_temporal_temporal', - 'tne_text_ttext', - 'tne_tfloat_float', - 'tne_tint_int', - 'tne_ttext_text', - 'temporal_spans', - 'temporal_split_each_n_spans', - 'temporal_split_n_spans', - 'tnumber_split_each_n_tboxes', - 'tnumber_split_n_tboxes', - 'tnumber_tboxes', - 'adjacent_numspan_tnumber', - 'adjacent_tbox_tnumber', - 'adjacent_temporal_temporal', - 'adjacent_temporal_tstzspan', - 'adjacent_tnumber_numspan', - 'adjacent_tnumber_tbox', - 'adjacent_tnumber_tnumber', - 'adjacent_tstzspan_temporal', - 'contained_numspan_tnumber', - 'contained_tbox_tnumber', - 'contained_temporal_temporal', - 'contained_temporal_tstzspan', - 'contained_tnumber_numspan', - 'contained_tnumber_tbox', - 'contained_tnumber_tnumber', - 'contained_tstzspan_temporal', - 'contains_numspan_tnumber', - 'contains_tbox_tnumber', - 'contains_temporal_tstzspan', - 'contains_temporal_temporal', - 'contains_tnumber_numspan', - 'contains_tnumber_tbox', - 'contains_tnumber_tnumber', - 'contains_tstzspan_temporal', - 'overlaps_numspan_tnumber', - 'overlaps_tbox_tnumber', - 'overlaps_temporal_temporal', - 'overlaps_temporal_tstzspan', - 'overlaps_tnumber_numspan', - 'overlaps_tnumber_tbox', - 'overlaps_tnumber_tnumber', - 'overlaps_tstzspan_temporal', - 'same_numspan_tnumber', - 'same_tbox_tnumber', - 'same_temporal_temporal', - 'same_temporal_tstzspan', - 'same_tnumber_numspan', - 'same_tnumber_tbox', - 'same_tnumber_tnumber', - 'same_tstzspan_temporal', - 'after_tbox_tnumber', - 'after_temporal_tstzspan', - 'after_temporal_temporal', - 'after_tnumber_tbox', - 'after_tnumber_tnumber', - 'after_tstzspan_temporal', - 'before_tbox_tnumber', - 'before_temporal_tstzspan', - 'before_temporal_temporal', - 'before_tnumber_tbox', - 'before_tnumber_tnumber', - 'before_tstzspan_temporal', - 'left_tbox_tnumber', - 'left_numspan_tnumber', - 'left_tnumber_numspan', - 'left_tnumber_tbox', - 'left_tnumber_tnumber', - 'overafter_tbox_tnumber', - 'overafter_temporal_tstzspan', - 'overafter_temporal_temporal', - 'overafter_tnumber_tbox', - 'overafter_tnumber_tnumber', - 'overafter_tstzspan_temporal', - 'overbefore_tbox_tnumber', - 'overbefore_temporal_tstzspan', - 'overbefore_temporal_temporal', - 'overbefore_tnumber_tbox', - 'overbefore_tnumber_tnumber', - 'overbefore_tstzspan_temporal', - 'overleft_numspan_tnumber', - 'overleft_tbox_tnumber', - 'overleft_tnumber_numspan', - 'overleft_tnumber_tbox', - 'overleft_tnumber_tnumber', - 'overright_numspan_tnumber', - 'overright_tbox_tnumber', - 'overright_tnumber_numspan', - 'overright_tnumber_tbox', - 'overright_tnumber_tnumber', - 'right_numspan_tnumber', - 'right_tbox_tnumber', - 'right_tnumber_numspan', - 'right_tnumber_tbox', - 'right_tnumber_tnumber', - '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', - 'temporal_derivative', - 'tfloat_exp', - 'tfloat_ln', - 'tfloat_log10', - 'tnumber_abs', - 'tnumber_trend', - 'float_angular_difference', - 'tnumber_angular_difference', - 'tnumber_delta_value', - 'textcat_text_ttext', - 'textcat_ttext_text', - 'textcat_ttext_ttext', - 'ttext_initcap', - 'ttext_upper', - 'ttext_lower', - 'tdistance_tfloat_float', - 'tdistance_tint_int', - 'tdistance_tnumber_tnumber', - 'nad_tboxfloat_tboxfloat', - 'nad_tboxint_tboxint', - 'nad_tfloat_float', - 'nad_tfloat_tfloat', - 'nad_tfloat_tbox', - 'nad_tint_int', - 'nad_tint_tbox', - 'nad_tint_tint', - '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', - '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', - 'temporal_time_bins', - 'temporal_time_split', - 'tfloat_time_boxes', - 'tfloat_value_bins', - 'tfloat_value_boxes', - 'tfloat_value_split', - 'tfloat_value_time_boxes', - 'tfloat_value_time_split', - 'tfloatbox_time_tiles', - 'tfloatbox_value_tiles', - 'tfloatbox_value_time_tiles', - 'tint_time_boxes', - 'tint_value_bins', - 'tint_value_boxes', - 'tint_value_split', - 'tint_value_time_boxes', - 'tint_value_time_split', - 'tintbox_time_tiles', - 'tintbox_value_tiles', - 'tintbox_value_time_tiles', - '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', - 'tnumber_basetype', - 'geo_basetype', - 'time_type', - 'set_type', - 'numset_type', - 'ensure_numset_type', - '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', - 'type_span_bbox', - 'span_tbox_type', - 'ensure_span_tbox_type', - 'numspan_basetype', - 'numspan_type', - 'ensure_numspan_type', - 'timespan_basetype', - 'timespan_type', - 'spanset_type', - 'timespanset_type', - 'ensure_timespanset_type', - 'temporal_type', - 'temptype_continuous', - 'basetype_byvalue', - 'basetype_varlength', - 'basetype_length', - 'talpha_type', - 'tnumber_type', - 'ensure_tnumber_type', - 'ensure_tnumber_basetype', - 'tnumber_spantype', - 'spatial_basetype', - 'tspatial_type', - 'ensure_tspatial_type', - 'tpoint_type', - 'ensure_tpoint_type', - 'tgeo_type', - 'ensure_tgeo_type', - 'tgeo_type_all', - 'ensure_tgeo_type_all', - 'tgeometry_type', - 'ensure_tgeometry_type', - 'tgeodetic_type', - 'ensure_tgeodetic_type', - 'ensure_tnumber_tpoint_type', - 'geo_as_ewkb', - 'geo_as_ewkt', - 'geo_as_geojson', - 'geo_as_hexewkb', - 'geo_as_text', - 'geo_from_ewkb', - 'geo_from_geojson', - 'geo_from_text', - 'geo_out', - 'geog_from_hexewkb', - 'geog_in', - 'geom_from_hexewkb', - 'geom_in', - 'box3d_make', - 'box3d_out', - 'gbox_make', - 'gbox_out', - 'geo_copy', - 'geogpoint_make2d', - 'geogpoint_make3dz', - 'geompoint_make2d', - 'geompoint_make3dz', - 'geom_to_geog', - 'geog_to_geom', - 'geo_is_empty', - 'geo_is_unitary', - 'geo_typename', - 'geog_area', - 'geog_centroid', - 'geog_length', - 'geog_perimeter', - 'geom_azimuth', - 'geom_length', - 'geom_perimeter', - 'line_numpoints', - 'line_point_n', - 'geo_reverse', - 'geo_round', - 'geo_set_srid', - 'geo_srid', - 'geo_transform', - 'geo_transform_pipeline', - 'geo_collect_garray', - 'geo_makeline_garray', - 'geo_num_points', - 'geo_num_geos', - 'geo_geo_n', - 'geo_pointarr', - 'geo_points', - 'geom_array_union', - 'geom_boundary', - 'geom_buffer', - 'geom_centroid', - 'geom_convex_hull', - 'geom_difference2d', - 'geom_intersection2d', - 'geom_intersection2d_coll', - 'geom_min_bounding_radius', - 'geom_shortestline2d', - 'geom_shortestline3d', - 'geom_unary_union', - 'line_interpolate_point', - 'line_locate_point', - 'line_substring', - 'geog_dwithin', - 'geog_intersects', - 'geom_contains', - 'geom_covers', - 'geom_disjoint2d', - 'geom_dwithin2d', - 'geom_dwithin3d', - 'geom_intersects2d', - 'geom_intersects3d', - 'geom_relate_pattern', - 'geom_touches', - 'geo_stboxes', - 'geo_split_each_n_stboxes', - 'geo_split_n_stboxes', - 'geog_distance', - 'geom_distance2d', - 'geom_distance3d', - 'geo_equals', - 'geo_same', - 'geogset_in', - 'geomset_in', - 'spatialset_as_text', - 'spatialset_as_ewkt', - 'geoset_make', - 'geo_to_set', - 'geoset_end_value', - 'geoset_start_value', - 'geoset_value_n', - 'geoset_values', - 'contained_geo_set', - 'contains_set_geo', - 'geo_union_transfn', - 'intersection_geo_set', - 'intersection_set_geo', - 'minus_geo_set', - 'minus_set_geo', - 'union_geo_set', - 'union_set_geo', - 'spatialset_set_srid', - 'spatialset_srid', - 'spatialset_transform', - 'spatialset_transform_pipeline', - 'stbox_as_hexwkb', - 'stbox_as_wkb', - 'stbox_from_hexwkb', - 'stbox_from_wkb', - 'stbox_in', - 'stbox_out', - 'geo_timestamptz_to_stbox', - 'geo_tstzspan_to_stbox', - 'stbox_copy', - 'stbox_make', - 'geo_to_stbox', - 'spatialset_to_stbox', - 'stbox_to_box3d', - 'stbox_to_gbox', - 'stbox_to_geo', - 'stbox_to_tstzspan', - 'timestamptz_to_stbox', - 'tstzset_to_stbox', - 'tstzspan_to_stbox', - 'tstzspanset_to_stbox', - 'stbox_area', - 'stbox_hash', - 'stbox_hash_extended', - 'stbox_hast', - 'stbox_hasx', - 'stbox_hasz', - 'stbox_isgeodetic', - 'stbox_perimeter', - 'stbox_tmax', - 'stbox_tmax_inc', - 'stbox_tmin', - 'stbox_tmin_inc', - 'stbox_volume', - 'stbox_xmax', - 'stbox_xmin', - 'stbox_ymax', - 'stbox_ymin', - 'stbox_zmax', - 'stbox_zmin', - 'stbox_expand_space', - 'stbox_expand_time', - 'stbox_get_space', - 'stbox_quad_split', - 'stbox_round', - 'stbox_shift_scale_time', - 'stboxarr_round', - 'stbox_set_srid', - 'stbox_srid', - 'stbox_transform', - 'stbox_transform_pipeline', - 'adjacent_stbox_stbox', - 'contained_stbox_stbox', - 'contains_stbox_stbox', - 'overlaps_stbox_stbox', - 'same_stbox_stbox', - 'above_stbox_stbox', - 'after_stbox_stbox', - 'back_stbox_stbox', - 'before_stbox_stbox', - 'below_stbox_stbox', - 'front_stbox_stbox', - 'left_stbox_stbox', - 'overabove_stbox_stbox', - 'overafter_stbox_stbox', - 'overback_stbox_stbox', - 'overbefore_stbox_stbox', - 'overbelow_stbox_stbox', - 'overfront_stbox_stbox', - 'overleft_stbox_stbox', - 'overright_stbox_stbox', - 'right_stbox_stbox', - 'union_stbox_stbox', - 'intersection_stbox_stbox', - 'stbox_cmp', - 'stbox_eq', - 'stbox_ge', - 'stbox_gt', - 'stbox_le', - 'stbox_lt', - 'stbox_ne', - 'tgeogpoint_from_mfjson', - 'tgeogpoint_in', - 'tgeography_from_mfjson', - 'tgeography_in', - 'tgeometry_from_mfjson', - 'tgeometry_in', - 'tgeompoint_from_mfjson', - 'tgeompoint_in', - 'tspatial_as_ewkt', - 'tspatial_as_text', - 'tspatial_out', - 'tgeo_from_base_temp', - 'tgeoinst_make', - 'tgeoseq_from_base_tstzset', - 'tgeoseq_from_base_tstzspan', - 'tgeoseqset_from_base_tstzspanset', - 'tpoint_from_base_temp', - 'tpointinst_make', - 'tpointseq_from_base_tstzset', - 'tpointseq_from_base_tstzspan', - 'tpointseq_make_coords', - 'tpointseqset_from_base_tstzspanset', - 'box3d_to_stbox', - 'gbox_to_stbox', - 'geomeas_to_tpoint', - 'tgeogpoint_to_tgeography', - 'tgeography_to_tgeogpoint', - 'tgeography_to_tgeometry', - 'tgeometry_to_tgeography', - 'tgeometry_to_tgeompoint', - 'tgeompoint_to_tgeometry', - 'tpoint_as_mvtgeom', - 'tpoint_tfloat_to_geomeas', - 'tspatial_to_stbox', - 'bearing_point_point', - 'bearing_tpoint_point', - 'bearing_tpoint_tpoint', - 'tgeo_centroid', - 'tgeo_convex_hull', - 'tgeo_end_value', - 'tgeo_start_value', - 'tgeo_traversed_area', - 'tgeo_value_at_timestamptz', - 'tgeo_value_n', - 'tgeo_values', - 'tpoint_angular_difference', - 'tpoint_azimuth', - 'tpoint_cumulative_length', - 'tpoint_direction', - 'tpoint_get_x', - 'tpoint_get_y', - 'tpoint_get_z', - 'tpoint_is_simple', - 'tpoint_length', - 'tpoint_speed', - 'tpoint_trajectory', - 'tpoint_twcentroid', - 'tgeo_affine', - 'tgeo_scale', - 'tpoint_make_simple', - 'tspatial_srid', - 'tspatial_set_srid', - 'tspatial_transform', - 'tspatial_transform_pipeline', - 'tgeo_at_geom', - 'tgeo_at_stbox', - 'tgeo_at_value', - 'tgeo_minus_geom', - 'tgeo_minus_stbox', - 'tgeo_minus_value', - 'tpoint_at_geom', - 'tpoint_at_value', - 'tpoint_minus_geom', - 'tpoint_minus_value', - 'always_eq_geo_tgeo', - 'always_eq_tgeo_geo', - 'always_eq_tgeo_tgeo', - 'always_ne_geo_tgeo', - 'always_ne_tgeo_geo', - 'always_ne_tgeo_tgeo', - 'ever_eq_geo_tgeo', - 'ever_eq_tgeo_geo', - 'ever_eq_tgeo_tgeo', - 'ever_ne_geo_tgeo', - 'ever_ne_tgeo_geo', - 'ever_ne_tgeo_tgeo', - 'teq_geo_tgeo', - 'teq_tgeo_geo', - 'tne_geo_tgeo', - 'tne_tgeo_geo', - 'tgeo_stboxes', - 'tgeo_space_boxes', - 'tgeo_space_time_boxes', - 'tgeo_split_each_n_stboxes', - 'tgeo_split_n_stboxes', - 'adjacent_stbox_tspatial', - 'adjacent_tspatial_stbox', - 'adjacent_tspatial_tspatial', - 'contained_stbox_tspatial', - 'contained_tspatial_stbox', - 'contained_tspatial_tspatial', - 'contains_stbox_tspatial', - 'contains_tspatial_stbox', - 'contains_tspatial_tspatial', - 'overlaps_stbox_tspatial', - 'overlaps_tspatial_stbox', - 'overlaps_tspatial_tspatial', - 'same_stbox_tspatial', - 'same_tspatial_stbox', - 'same_tspatial_tspatial', - 'above_stbox_tspatial', - 'above_tspatial_stbox', - 'above_tspatial_tspatial', - 'after_stbox_tspatial', - 'after_tspatial_stbox', - 'after_tspatial_tspatial', - 'back_stbox_tspatial', - 'back_tspatial_stbox', - 'back_tspatial_tspatial', - 'before_stbox_tspatial', - 'before_tspatial_stbox', - 'before_tspatial_tspatial', - 'below_stbox_tspatial', - 'below_tspatial_stbox', - 'below_tspatial_tspatial', - 'front_stbox_tspatial', - 'front_tspatial_stbox', - 'front_tspatial_tspatial', - 'left_stbox_tspatial', - 'left_tspatial_stbox', - 'left_tspatial_tspatial', - 'overabove_stbox_tspatial', - 'overabove_tspatial_stbox', - 'overabove_tspatial_tspatial', - 'overafter_stbox_tspatial', - 'overafter_tspatial_stbox', - 'overafter_tspatial_tspatial', - 'overback_stbox_tspatial', - 'overback_tspatial_stbox', - 'overback_tspatial_tspatial', - 'overbefore_stbox_tspatial', - 'overbefore_tspatial_stbox', - 'overbefore_tspatial_tspatial', - 'overbelow_stbox_tspatial', - 'overbelow_tspatial_stbox', - 'overbelow_tspatial_tspatial', - 'overfront_stbox_tspatial', - 'overfront_tspatial_stbox', - 'overfront_tspatial_tspatial', - 'overleft_stbox_tspatial', - 'overleft_tspatial_stbox', - 'overleft_tspatial_tspatial', - 'overright_stbox_tspatial', - 'overright_tspatial_stbox', - 'overright_tspatial_tspatial', - 'right_stbox_tspatial', - 'right_tspatial_stbox', - 'right_tspatial_tspatial', - 'acontains_geo_tgeo', - 'acontains_tgeo_geo', - 'acontains_tgeo_tgeo', - 'adisjoint_tgeo_geo', - 'adisjoint_tgeo_tgeo', - 'adwithin_tgeo_geo', - 'adwithin_tgeo_tgeo', - 'aintersects_tgeo_geo', - 'aintersects_tgeo_tgeo', - 'atouches_tgeo_geo', - 'atouches_tgeo_tgeo', - 'atouches_tpoint_geo', - 'econtains_geo_tgeo', - 'econtains_tgeo_geo', - 'econtains_tgeo_tgeo', - 'ecovers_geo_tgeo', - 'ecovers_tgeo_geo', - 'ecovers_tgeo_tgeo', - 'edisjoint_tgeo_geo', - 'edisjoint_tgeo_tgeo', - 'edwithin_tgeo_geo', - 'edwithin_tgeo_tgeo', - 'eintersects_tgeo_geo', - 'eintersects_tgeo_tgeo', - 'etouches_tgeo_geo', - 'etouches_tgeo_tgeo', - 'etouches_tpoint_geo', - 'tcontains_geo_tgeo', - 'tcontains_tgeo_geo', - 'tcontains_tgeo_tgeo', - 'tcovers_geo_tgeo', - 'tcovers_tgeo_geo', - 'tcovers_tgeo_tgeo', - 'tdisjoint_geo_tgeo', - 'tdisjoint_tgeo_geo', - 'tdisjoint_tgeo_tgeo', - 'tdwithin_geo_tgeo', - 'tdwithin_tgeo_geo', - 'tdwithin_tgeo_tgeo', - 'tintersects_geo_tgeo', - 'tintersects_tgeo_geo', - 'tintersects_tgeo_tgeo', - 'ttouches_geo_tgeo', - 'ttouches_tgeo_geo', - 'ttouches_tgeo_tgeo', - 'tdistance_tgeo_geo', - 'tdistance_tgeo_tgeo', - 'nad_stbox_geo', - 'nad_stbox_stbox', - 'nad_tgeo_geo', - 'nad_tgeo_stbox', - 'nad_tgeo_tgeo', - 'nai_tgeo_geo', - 'nai_tgeo_tgeo', - 'shortestline_tgeo_geo', - 'shortestline_tgeo_tgeo', - 'tpoint_tcentroid_finalfn', - 'tpoint_tcentroid_transfn', - 'tspatial_extent_transfn', - 'stbox_get_space_tile', - 'stbox_get_space_time_tile', - 'stbox_get_time_tile', - 'stbox_space_tiles', - 'stbox_space_time_tiles', - 'stbox_time_tiles', - 'tgeo_space_split', - 'tgeo_space_time_split', - 'geo_cluster_kmeans', - 'geo_cluster_dbscan', - 'geo_cluster_intersecting', - 'geo_cluster_within', - 'gsl_get_generation_rng', - 'gsl_get_aggregation_rng', - 'datum_ceil', - 'datum_degrees', - 'datum_float_round', - 'datum_floor', - 'datum_hash', - 'datum_hash_extended', - 'datum_radians', - 'floatspan_round_set', - 'set_in', - 'set_out', - 'span_in', - 'span_out', - 'spanset_in', - 'spanset_out', - 'set_make', - 'set_make_exp', - 'set_make_free', - 'span_make', - 'span_set', - 'spanset_make_exp', - 'spanset_make_free', - 'set_span', - 'set_spanset', - 'value_set_span', - 'value_set', - 'value_span', - 'value_spanset', - 'numspan_width', - 'numspanset_width', - 'set_end_value', - 'set_mem_size', - 'set_set_subspan', - 'set_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_set_intspan', - 'intspan_set_floatspan', - 'numset_shift_scale', - 'numspan_expand', - 'numspan_shift_scale', - 'numspanset_shift_scale', - 'set_compact', - 'span_expand', - 'spanset_compact', - 'tbox_expand_value', - 'textcat_textset_text_common', - 'tstzspan_set_datespan', - 'adjacent_span_value', - 'adjacent_spanset_value', - 'adjacent_value_spanset', - 'contained_value_set', - 'contained_value_span', - 'contained_value_spanset', - 'contains_set_value', - 'contains_span_value', - 'contains_spanset_value', - 'ovadj_span_span', - 'left_set_value', - 'left_span_value', - 'left_spanset_value', - 'left_value_set', - 'left_value_span', - 'left_value_spanset', - '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', - 'right_value_set', - 'right_set_value', - 'right_value_span', - 'right_value_spanset', - 'right_span_value', - 'right_spanset_value', - 'bbox_type', - 'bbox_get_size', - 'bbox_max_dims', - 'temporal_bbox_eq', - 'temporal_bbox_cmp', - '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', - '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', - 'tbox_set', - 'float_set_tbox', - 'int_set_tbox', - 'number_set_tbox', - 'number_tbox', - 'numset_set_tbox', - 'numspan_set_tbox', - 'timestamptz_set_tbox', - 'tstzset_set_tbox', - 'tstzspan_set_tbox', - 'tbox_shift_scale_value', - 'tbox_expand', - 'inter_tbox_tbox', - 'tboolinst_in', - 'tboolseq_in', - 'tboolseqset_in', - 'temporal_in', - 'temporal_out', - 'temparr_out', - 'tfloatinst_in', - 'tfloatseq_in', - 'tfloatseqset_in', - 'tinstant_in', - 'tinstant_out', - 'tintinst_in', - 'tintseq_in', - 'tintseqset_in', - 'tsequence_in', - 'tsequence_out', - 'tsequenceset_in', - 'tsequenceset_out', - 'ttextinst_in', - 'ttextseq_in', - 'ttextseqset_in', - 'temporal_from_mfjson', - 'temporal_from_base_temp', - 'tinstant_copy', - 'tinstant_make', - 'tinstant_make_free', - 'tsequence_copy', - 'tsequence_from_base_temp', - 'tsequence_from_base_tstzset', - 'tsequence_from_base_tstzspan', - 'tsequence_make_exp', - 'tsequence_make_free', - 'tsequenceset_copy', - 'tseqsetarr_to_tseqset', - 'tsequenceset_from_base_temp', - 'tsequenceset_from_base_tstzspanset', - 'tsequenceset_make_exp', - 'tsequenceset_make_free', - 'temporal_set_tstzspan', - 'tinstant_set_tstzspan', - 'tnumber_set_tbox', - 'tnumberinst_set_tbox', - 'tnumberseq_set_tbox', - 'tnumberseqset_set_tbox', - 'tsequence_set_tstzspan', - 'tsequenceset_set_tstzspan', - 'temporal_end_inst', - 'temporal_end_value', - 'temporal_inst_n', - 'temporal_insts_p', - 'temporal_max_inst_p', - 'temporal_max_value', - 'temporal_mem_size', - 'temporal_min_inst_p', - 'temporal_min_value', - 'temporal_sequences_p', - 'temporal_set_bbox', - 'temporal_start_inst', - 'temporal_start_value', - 'temporal_values_p', - 'temporal_value_n', - 'temporal_values', - 'tinstant_hash', - 'tinstant_insts', - 'tinstant_set_bbox', - 'tinstant_time', - 'tinstant_timestamps', - 'tinstant_value_p', - 'tinstant_value', - 'tinstant_value_at_timestamptz', - 'tinstant_values_p', - 'tnumber_set_span', - 'tnumberinst_valuespans', - 'tnumberseq_avg_val', - 'tnumberseq_valuespans', - 'tnumberseqset_avg_val', - 'tnumberseqset_valuespans', - 'tsequence_duration', - 'tsequence_end_timestamptz', - 'tsequence_hash', - 'tsequence_insts_p', - 'tsequence_max_inst_p', - 'tsequence_max_val', - 'tsequence_min_inst_p', - 'tsequence_min_val', - 'tsequence_segments', - 'tsequence_seqs', - 'tsequence_start_timestamptz', - 'tsequence_time', - 'tsequence_timestamps', - 'tsequence_value_at_timestamptz', - 'tsequence_values_p', - 'tsequenceset_duration', - 'tsequenceset_end_timestamptz', - 'tsequenceset_hash', - 'tsequenceset_inst_n', - 'tsequenceset_insts_p', - 'tsequenceset_max_inst_p', - 'tsequenceset_max_val', - 'tsequenceset_min_inst_p', - 'tsequenceset_min_val', - 'tsequenceset_num_instants', - 'tsequenceset_num_timestamps', - 'tsequenceset_segments', - 'tsequenceset_sequences_p', - 'tsequenceset_start_timestamptz', - 'tsequenceset_time', - 'tsequenceset_timestamptz_n', - 'tsequenceset_timestamps', - 'tsequenceset_value_at_timestamptz', - 'tsequenceset_value_n', - 'tsequenceset_values_p', - 'temporal_restart', - 'temporal_tsequence', - 'temporal_tsequenceset', - 'tinstant_shift_time', - 'tinstant_to_tsequence', - 'tinstant_to_tsequence_free', - 'tinstant_to_tsequenceset', - 'tnumber_shift_scale_value', - 'tnumberinst_shift_value', - 'tnumberseq_shift_scale_value', - 'tnumberseqset_shift_scale_value', - 'tsequence_restart', - 'tsequence_set_interp', - 'tsequence_shift_scale_time', - 'tsequence_subseq', - 'tsequence_to_tinstant', - 'tsequence_to_tsequenceset', - 'tsequence_to_tsequenceset_free', - 'tsequence_to_tsequenceset_interp', - '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', - 'tcontseq_after_timestamptz', - 'tcontseq_before_timestamptz', - 'tcontseq_restrict_minmax', - 'tdiscseq_after_timestamptz', - 'tdiscseq_before_timestamptz', - 'tdiscseq_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_after_timestamptz', - 'tinstant_before_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', - 'tsequence_at_timestamptz', - 'tsequence_restrict_tstzspan', - 'tsequence_restrict_tstzspanset', - 'tsequenceset_after_timestamptz', - 'tsequenceset_before_timestamptz', - '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_ne_base_temporal', - 'always_ne_temporal_base', - 'always_ge_base_temporal', - 'always_ge_temporal_base', - 'always_gt_base_temporal', - 'always_gt_temporal_base', - 'always_le_base_temporal', - 'always_le_temporal_base', - 'always_lt_base_temporal', - 'always_lt_temporal_base', - 'ever_eq_base_temporal', - 'ever_eq_temporal_base', - 'ever_ne_base_temporal', - 'ever_ne_temporal_base', - 'ever_ge_base_temporal', - 'ever_ge_temporal_base', - 'ever_gt_base_temporal', - 'ever_gt_temporal_base', - 'ever_le_base_temporal', - 'ever_le_temporal_base', - 'ever_lt_base_temporal', - 'ever_lt_temporal_base', - 'tnumberinst_abs', - 'tnumberseq_abs', - 'tnumberseq_angular_difference', - 'tnumberseq_delta_value', - 'tnumberseqset_abs', - 'tnumberseqset_angular_difference', - 'tnumberseqset_delta_value', - 'tdistance_tnumber_number', - 'nad_tbox_tbox', - 'nad_tnumber_number', - 'nad_tnumber_tbox', - 'nad_tnumber_tnumber', - 'tnumberseq_integral', - 'tnumberseq_twavg', - 'tnumberseqset_integral', - 'tnumberseqset_twavg', - 'temporal_compact', - 'tsequence_compact', - 'tsequenceset_compact', - 'temporal_skiplist_make', - 'skiplist_search', - 'skiplist_free', - 'skiplist_splice', - 'temporal_skiplist_splice', - 'skiplist_values', - 'skiplist_keys_values', - 'temporal_app_tinst_transfn', - 'temporal_app_tseq_transfn', - 'span_bins', - 'spanset_bins', - 'tnumber_value_bins', - 'tnumber_value_time_boxes', - 'tnumber_value_split', - 'tbox_get_value_time_tile', - 'tnumber_value_time_split', - 'proj_get_context', - 'datum_geo_round', - 'point_round', - 'stbox_set', - 'gbox_set_stbox', - 'geo_set_stbox', - 'geoarr_set_stbox', - 'spatial_set_stbox', - 'spatialset_set_stbox', - 'stbox_set_box3d', - 'stbox_set_gbox', - 'tstzset_set_stbox', - 'tstzspan_set_stbox', - 'tstzspanset_set_stbox', - 'stbox_expand', - 'inter_stbox_stbox', - 'stbox_geo', - 'tgeogpointinst_in', - 'tgeogpointseq_in', - 'tgeogpointseqset_in', - 'tgeompointinst_in', - 'tgeompointseq_in', - 'tgeompointseqset_in', - 'tgeographyinst_in', - 'tgeographyseq_in', - 'tgeographyseqset_in', - 'tgeometryinst_in', - 'tgeometryseq_in', - 'tgeometryseqset_in', - 'tspatial_set_stbox', - 'tgeoinst_set_stbox', - 'tspatialseq_set_stbox', - 'tspatialseqset_set_stbox', - 'tgeo_restrict_geom', - 'tgeo_restrict_stbox', - 'tgeoinst_restrict_geom', - 'tgeoinst_restrict_stbox', - 'tgeoseq_restrict_geom', - 'tgeoseq_restrict_stbox', - 'tgeoseqset_restrict_geom', - 'tgeoseqset_restrict_stbox', - 'spatial_srid', - 'spatial_set_srid', - 'tspatialinst_srid', - 'tpointseq_azimuth', - 'tpointseq_cumulative_length', - 'tpointseq_is_simple', - 'tpointseq_length', - 'tpointseq_linear_trajectory', - 'tgeoseq_stboxes', - 'tgeoseq_split_n_stboxes', - 'tpointseqset_azimuth', - 'tpointseqset_cumulative_length', - 'tpointseqset_is_simple', - 'tpointseqset_length', - 'tgeoseqset_stboxes', - 'tgeoseqset_split_n_stboxes', - 'tpoint_get_coord', - 'tgeominst_tgeoginst', - 'tgeomseq_tgeogseq', - 'tgeomseqset_tgeogseqset', - 'tgeom_tgeog', - 'tgeo_tpoint', - 'tspatialinst_set_srid', - 'tpointseq_make_simple', - 'tspatialseq_set_srid', - 'tpointseqset_make_simple', - 'tspatialseqset_set_srid', - 'tpointseq_twcentroid', - 'tpointseqset_twcentroid', - 'npoint_as_ewkt', - 'npoint_as_hexwkb', - 'npoint_as_text', - 'npoint_as_wkb', - 'npoint_from_hexwkb', - 'npoint_from_wkb', - 'npoint_in', - 'npoint_out', - 'nsegment_in', - 'nsegment_out', - 'npoint_make', - 'nsegment_make', - 'geompoint_to_npoint', - 'geom_to_nsegment', - 'npoint_to_geompoint', - 'npoint_to_nsegment', - 'npoint_to_stbox', - 'nsegment_to_geom', - 'nsegment_to_stbox', - 'npoint_hash', - 'npoint_hash_extended', - 'npoint_position', - 'npoint_route', - 'nsegment_end_position', - 'nsegment_route', - 'nsegment_start_position', - 'route_exists', - 'route_geom', - 'route_length', - 'npoint_round', - 'nsegment_round', - 'get_srid_ways', - 'npoint_srid', - 'nsegment_srid', - 'npoint_timestamptz_to_stbox', - 'npoint_tstzspan_to_stbox', - 'npoint_cmp', - 'npoint_eq', - 'npoint_ge', - 'npoint_gt', - 'npoint_le', - 'npoint_lt', - 'npoint_ne', - 'npoint_same', - 'nsegment_cmp', - 'nsegment_eq', - 'nsegment_ge', - 'nsegment_gt', - 'nsegment_le', - 'nsegment_lt', - 'nsegment_ne', - 'npointset_in', - 'npointset_out', - 'npointset_make', - 'npoint_to_set', - 'npointset_end_value', - 'npointset_routes', - 'npointset_start_value', - 'npointset_value_n', - 'npointset_values', - 'contained_npoint_set', - 'contains_set_npoint', - 'intersection_npoint_set', - 'intersection_set_npoint', - 'minus_npoint_set', - 'minus_set_npoint', - 'npoint_union_transfn', - 'union_npoint_set', - 'union_set_npoint', - 'tnpoint_in', - 'tnpoint_out', - 'tnpointinst_make', - 'tgeompoint_to_tnpoint', - 'tnpoint_to_tgeompoint', - 'tnpoint_cumulative_length', - 'tnpoint_length', - 'tnpoint_positions', - 'tnpoint_route', - 'tnpoint_routes', - 'tnpoint_speed', - 'tnpoint_trajectory', - 'tnpoint_twcentroid', - 'tnpoint_at_geom', - 'tnpoint_at_npoint', - 'tnpoint_at_npointset', - 'tnpoint_at_stbox', - 'tnpoint_minus_geom', - 'tnpoint_minus_npoint', - 'tnpoint_minus_npointset', - 'tnpoint_minus_stbox', - 'tdistance_tnpoint_npoint', - 'tdistance_tnpoint_point', - 'tdistance_tnpoint_tnpoint', - 'nad_tnpoint_geo', - 'nad_tnpoint_npoint', - 'nad_tnpoint_stbox', - 'nad_tnpoint_tnpoint', - 'nai_tnpoint_geo', - 'nai_tnpoint_npoint', - 'nai_tnpoint_tnpoint', - 'shortestline_tnpoint_geo', - 'shortestline_tnpoint_npoint', - 'shortestline_tnpoint_tnpoint', - 'tnpoint_tcentroid_transfn', - 'always_eq_npoint_tnpoint', - 'always_eq_tnpoint_npoint', - 'always_eq_tnpoint_tnpoint', - 'always_ne_npoint_tnpoint', - 'always_ne_tnpoint_npoint', - 'always_ne_tnpoint_tnpoint', - 'ever_eq_npoint_tnpoint', - 'ever_eq_tnpoint_npoint', - 'ever_eq_tnpoint_tnpoint', - 'ever_ne_npoint_tnpoint', - 'ever_ne_tnpoint_npoint', - 'ever_ne_tnpoint_tnpoint', - 'teq_tnpoint_npoint', - 'tne_tnpoint_npoint', - + "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", + "float_to_datum", + "int_to_datum", + "tbox_expand_float", + "tbox_expand_int", + "tbox_shift_scale_float", + "tbox_shift_scale_int", + "date_in", + "date_out", + "interval_cmp", + "interval_in", + "interval_out", + "time_in", + "time_out", + "timestamp_in", + "timestamp_out", + "timestamptz_in", + "timestamptz_out", + "rtree_create_intspan", + "rtree_create_bigintspan", + "rtree_create_floatspan", + "rtree_create_datespan", + "rtree_create_tstzspan", + "rtree_create_tbox", + "rtree_create_stbox", + "rtree_free", + "rtree_insert", + "rtree_search", + "meos_errno", + "meos_errno_set", + "meos_errno_restore", + "meos_errno_reset", + "meos_finalize_projsrs", + "meos_finalize_ways", + "meos_set_datestyle", + "meos_set_intervalstyle", + "meos_get_datestyle", + "meos_get_intervalstyle", + "meos_set_spatial_ref_sys_csv", + "meos_initialize", + "meos_finalize", + "add_date_int", + "add_interval_interval", + "add_timestamptz_interval", + "bool_in", + "bool_out", + "cstring2text", + "date_to_timestamp", + "date_to_timestamptz", + "float_exp", + "float_ln", + "float_log10", + "float8_out", + "float_round", + "int32_cmp", + "int64_cmp", + "interval_make", + "minus_date_date", + "minus_date_int", + "minus_timestamptz_interval", + "minus_timestamptz_timestamptz", + "mul_interval_double", + "pg_date_in", + "pg_date_out", + "pg_interval_cmp", + "pg_interval_in", + "pg_interval_out", + "pg_timestamp_in", + "pg_timestamp_out", + "pg_timestamptz_in", + "pg_timestamptz_out", + "text2cstring", + "text_cmp", + "text_copy", + "text_in", + "text_initcap", + "text_lower", + "text_out", + "text_upper", + "textcat_text_text", + "timestamptz_shift", + "timestamp_to_date", + "timestamptz_to_date", + "bigintset_in", + "bigintset_out", + "bigintspan_expand", + "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_expand", + "floatspan_in", + "floatspan_out", + "floatspanset_in", + "floatspanset_out", + "intset_in", + "intset_out", + "intspan_expand", + "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", + "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", + "int_to_set", + "int_to_span", + "int_to_spanset", + "intset_to_floatset", + "intspan_to_floatspan", + "intspanset_to_floatspanset", + "set_to_span", + "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", + "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", + "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_spanarr", + "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_timestamps", + "tstzspanset_timestamptz_n", + "tstzspanset_upper", + "bigintset_shift_scale", + "bigintspan_shift_scale", + "bigintspanset_shift_scale", + "dateset_shift_scale", + "datespan_shift_scale", + "datespanset_shift_scale", + "floatset_ceil", + "floatset_degrees", + "floatset_floor", + "floatset_radians", + "floatset_shift_scale", + "floatspan_ceil", + "floatspan_degrees", + "floatspan_floor", + "floatspan_radians", + "floatspan_round", + "floatspan_shift_scale", + "floatspanset_ceil", + "floatspanset_floor", + "floatspanset_degrees", + "floatspanset_radians", + "floatspanset_round", + "floatspanset_shift_scale", + "intset_shift_scale", + "intspan_shift_scale", + "intspanset_shift_scale", + "tstzspan_expand", + "set_round", + "textcat_text_textset", + "textcat_textset_text", + "textset_initcap", + "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", + "set_spans", + "set_split_each_n_spans", + "set_split_n_spans", + "spanset_spans", + "spanset_split_each_n_spans", + "spanset_split_n_spans", + "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_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_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_int_set", + "intersection_set_bigint", + "intersection_set_date", + "intersection_set_float", + "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_int_set", + "minus_int_span", + "minus_int_spanset", + "minus_set_bigint", + "minus_set_date", + "minus_set_float", + "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_int_set", + "union_int_span", + "union_int_spanset", + "union_set_bigint", + "union_set_date", + "union_set_float", + "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", + "bigint_get_bin", + "bigintspan_bins", + "bigintspanset_bins", + "date_get_bin", + "datespan_bins", + "datespanset_bins", + "float_get_bin", + "floatspan_bins", + "floatspanset_bins", + "int_get_bin", + "intspan_bins", + "intspanset_bins", + "timestamptz_get_bin", + "tstzspan_bins", + "tstzspanset_bins", + "tbox_as_hexwkb", + "tbox_as_wkb", + "tbox_from_hexwkb", + "tbox_from_wkb", + "tbox_in", + "tbox_out", + "float_timestamptz_to_tbox", + "float_tstzspan_to_tbox", + "int_timestamptz_to_tbox", + "int_tstzspan_to_tbox", + "numspan_tstzspan_to_tbox", + "numspan_timestamptz_to_tbox", + "tbox_copy", + "tbox_make", + "float_to_tbox", + "int_to_tbox", + "set_to_tbox", + "span_to_tbox", + "spanset_to_tbox", + "tbox_to_intspan", + "tbox_to_floatspan", + "tbox_to_tstzspan", + "timestamptz_to_tbox", + "tbox_hash", + "tbox_hash_extended", + "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", + "tbox_expand_time", + "tbox_round", + "tbox_shift_scale_time", + "tfloatbox_expand", + "tfloatbox_shift_scale", + "tintbox_expand", + "tintbox_shift_scale", + "union_tbox_tbox", + "intersection_tbox_tbox", + "adjacent_tbox_tbox", + "contained_tbox_tbox", + "contains_tbox_tbox", + "overlaps_tbox_tbox", + "same_tbox_tbox", + "after_tbox_tbox", + "before_tbox_tbox", + "left_tbox_tbox", + "overafter_tbox_tbox", + "overbefore_tbox_tbox", + "overleft_tbox_tbox", + "overright_tbox_tbox", + "right_tbox_tbox", + "tbox_cmp", + "tbox_eq", + "tbox_ge", + "tbox_gt", + "tbox_le", + "tbox_lt", + "tbox_ne", + "tbool_from_mfjson", + "tbool_in", + "tbool_out", + "temporal_as_hexwkb", + "temporal_as_mfjson", + "temporal_as_wkb", + "temporal_from_hexwkb", + "temporal_from_wkb", + "tfloat_from_mfjson", + "tfloat_in", + "tfloat_out", + "tint_from_mfjson", + "tint_in", + "tint_out", + "ttext_from_mfjson", + "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_tstzset", + "tfloatseq_from_base_tstzspan", + "tfloatseqset_from_base_tstzspanset", + "tint_from_base_temp", + "tintinst_make", + "tintseq_from_base_tstzset", + "tintseq_from_base_tstzspan", + "tintseqset_from_base_tstzspanset", + "tsequence_make", + "tsequenceset_make", + "tsequenceset_make_gaps", + "ttext_from_base_temp", + "ttextinst_make", + "ttextseq_from_base_tstzset", + "ttextseq_from_base_tstzspan", + "ttextseqset_from_base_tstzspanset", + "tbool_to_tint", + "temporal_to_tstzspan", + "tfloat_to_tint", + "tint_to_tfloat", + "tnumber_to_span", + "tnumber_to_tbox", + "tbool_end_value", + "tbool_start_value", + "tbool_value_at_timestamptz", + "tbool_value_n", + "tbool_values", + "temporal_duration", + "temporal_end_instant", + "temporal_end_sequence", + "temporal_end_timestamptz", + "temporal_hash", + "temporal_instant_n", + "temporal_instants", + "temporal_interp", + "temporal_lower_inc", + "temporal_max_instant", + "temporal_min_instant", + "temporal_num_instants", + "temporal_num_sequences", + "temporal_num_timestamps", + "temporal_segm_duration", + "temporal_segments", + "temporal_sequence_n", + "temporal_sequences", + "temporal_start_instant", + "temporal_start_sequence", + "temporal_start_timestamptz", + "temporal_stops", + "temporal_subtype", + "temporal_time", + "temporal_timestamps", + "temporal_timestamptz_n", + "temporal_upper_inc", + "tfloat_end_value", + "tfloat_min_value", + "tfloat_max_value", + "tfloat_start_value", + "tfloat_value_at_timestamptz", + "tfloat_value_n", + "tfloat_values", + "tint_end_value", + "tint_max_value", + "tint_min_value", + "tint_start_value", + "tint_value_at_timestamptz", + "tint_value_n", + "tint_values", + "tnumber_avg_value", + "tnumber_integral", + "tnumber_twavg", + "tnumber_valuespans", + "ttext_end_value", + "ttext_max_value", + "ttext_min_value", + "ttext_start_value", + "ttext_value_at_timestamptz", + "ttext_value_n", + "ttext_values", + "float_degrees", + "temparr_round", + "temporal_round", + "temporal_scale_time", + "temporal_set_interp", + "temporal_shift_scale_time", + "temporal_shift_time", + "temporal_to_tinstant", + "temporal_to_tsequence", + "temporal_to_tsequenceset", + "tfloat_ceil", + "tfloat_degrees", + "tfloat_floor", + "tfloat_radians", + "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_timestamptz", + "temporal_delete_tstzset", + "temporal_delete_tstzspan", + "temporal_delete_tstzspanset", + "temporal_insert", + "temporal_merge", + "temporal_merge_array", + "temporal_update", + "tbool_at_value", + "tbool_minus_value", + "temporal_after_timestamptz", + "temporal_at_max", + "temporal_at_min", + "temporal_at_timestamptz", + "temporal_at_tstzset", + "temporal_at_tstzspan", + "temporal_at_tstzspanset", + "temporal_at_values", + "temporal_before_timestamptz", + "temporal_minus_max", + "temporal_minus_min", + "temporal_minus_timestamptz", + "temporal_minus_tstzset", + "temporal_minus_tstzspan", + "temporal_minus_tstzspanset", + "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", + "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_tbool_bool", + "always_eq_temporal_temporal", + "always_eq_text_ttext", + "always_eq_tfloat_float", + "always_eq_tint_int", + "always_eq_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", + "always_ne_bool_tbool", + "always_ne_float_tfloat", + "always_ne_int_tint", + "always_ne_tbool_bool", + "always_ne_temporal_temporal", + "always_ne_text_ttext", + "always_ne_tfloat_float", + "always_ne_tint_int", + "always_ne_ttext_text", + "ever_eq_bool_tbool", + "ever_eq_float_tfloat", + "ever_eq_int_tint", + "ever_eq_tbool_bool", + "ever_eq_temporal_temporal", + "ever_eq_text_ttext", + "ever_eq_tfloat_float", + "ever_eq_tint_int", + "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_tbool_bool", + "ever_ne_temporal_temporal", + "ever_ne_text_ttext", + "ever_ne_tfloat_float", + "ever_ne_tint_int", + "ever_ne_ttext_text", + "teq_bool_tbool", + "teq_float_tfloat", + "teq_int_tint", + "teq_tbool_bool", + "teq_temporal_temporal", + "teq_text_ttext", + "teq_tfloat_float", + "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_tbool_bool", + "tne_temporal_temporal", + "tne_text_ttext", + "tne_tfloat_float", + "tne_tint_int", + "tne_ttext_text", + "temporal_spans", + "temporal_split_each_n_spans", + "temporal_split_n_spans", + "tnumber_split_each_n_tboxes", + "tnumber_split_n_tboxes", + "tnumber_tboxes", + "adjacent_numspan_tnumber", + "adjacent_tbox_tnumber", + "adjacent_temporal_temporal", + "adjacent_temporal_tstzspan", + "adjacent_tnumber_numspan", + "adjacent_tnumber_tbox", + "adjacent_tnumber_tnumber", + "adjacent_tstzspan_temporal", + "contained_numspan_tnumber", + "contained_tbox_tnumber", + "contained_temporal_temporal", + "contained_temporal_tstzspan", + "contained_tnumber_numspan", + "contained_tnumber_tbox", + "contained_tnumber_tnumber", + "contained_tstzspan_temporal", + "contains_numspan_tnumber", + "contains_tbox_tnumber", + "contains_temporal_tstzspan", + "contains_temporal_temporal", + "contains_tnumber_numspan", + "contains_tnumber_tbox", + "contains_tnumber_tnumber", + "contains_tstzspan_temporal", + "overlaps_numspan_tnumber", + "overlaps_tbox_tnumber", + "overlaps_temporal_temporal", + "overlaps_temporal_tstzspan", + "overlaps_tnumber_numspan", + "overlaps_tnumber_tbox", + "overlaps_tnumber_tnumber", + "overlaps_tstzspan_temporal", + "same_numspan_tnumber", + "same_tbox_tnumber", + "same_temporal_temporal", + "same_temporal_tstzspan", + "same_tnumber_numspan", + "same_tnumber_tbox", + "same_tnumber_tnumber", + "same_tstzspan_temporal", + "after_tbox_tnumber", + "after_temporal_tstzspan", + "after_temporal_temporal", + "after_tnumber_tbox", + "after_tnumber_tnumber", + "after_tstzspan_temporal", + "before_tbox_tnumber", + "before_temporal_tstzspan", + "before_temporal_temporal", + "before_tnumber_tbox", + "before_tnumber_tnumber", + "before_tstzspan_temporal", + "left_tbox_tnumber", + "left_numspan_tnumber", + "left_tnumber_numspan", + "left_tnumber_tbox", + "left_tnumber_tnumber", + "overafter_tbox_tnumber", + "overafter_temporal_tstzspan", + "overafter_temporal_temporal", + "overafter_tnumber_tbox", + "overafter_tnumber_tnumber", + "overafter_tstzspan_temporal", + "overbefore_tbox_tnumber", + "overbefore_temporal_tstzspan", + "overbefore_temporal_temporal", + "overbefore_tnumber_tbox", + "overbefore_tnumber_tnumber", + "overbefore_tstzspan_temporal", + "overleft_numspan_tnumber", + "overleft_tbox_tnumber", + "overleft_tnumber_numspan", + "overleft_tnumber_tbox", + "overleft_tnumber_tnumber", + "overright_numspan_tnumber", + "overright_tbox_tnumber", + "overright_tnumber_numspan", + "overright_tnumber_tbox", + "overright_tnumber_tnumber", + "right_numspan_tnumber", + "right_tbox_tnumber", + "right_tnumber_numspan", + "right_tnumber_tbox", + "right_tnumber_tnumber", + "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", + "temporal_derivative", + "tfloat_exp", + "tfloat_ln", + "tfloat_log10", + "tnumber_abs", + "tnumber_trend", + "float_angular_difference", + "tnumber_angular_difference", + "tnumber_delta_value", + "textcat_text_ttext", + "textcat_ttext_text", + "textcat_ttext_ttext", + "ttext_initcap", + "ttext_upper", + "ttext_lower", + "tdistance_tfloat_float", + "tdistance_tint_int", + "tdistance_tnumber_tnumber", + "nad_tboxfloat_tboxfloat", + "nad_tboxint_tboxint", + "nad_tfloat_float", + "nad_tfloat_tfloat", + "nad_tfloat_tbox", + "nad_tint_int", + "nad_tint_tbox", + "nad_tint_tint", + "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", + "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", + "temporal_time_bins", + "temporal_time_split", + "tfloat_time_boxes", + "tfloat_value_bins", + "tfloat_value_boxes", + "tfloat_value_split", + "tfloat_value_time_boxes", + "tfloat_value_time_split", + "tfloatbox_time_tiles", + "tfloatbox_value_tiles", + "tfloatbox_value_time_tiles", + "tint_time_boxes", + "tint_value_bins", + "tint_value_boxes", + "tint_value_split", + "tint_value_time_boxes", + "tint_value_time_split", + "tintbox_time_tiles", + "tintbox_value_tiles", + "tintbox_value_time_tiles", + "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", + "tnumber_basetype", + "geo_basetype", + "time_type", + "set_type", + "numset_type", + "ensure_numset_type", + "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", + "type_span_bbox", + "span_tbox_type", + "ensure_span_tbox_type", + "numspan_basetype", + "numspan_type", + "ensure_numspan_type", + "timespan_basetype", + "timespan_type", + "spanset_type", + "timespanset_type", + "ensure_timespanset_type", + "temporal_type", + "temptype_continuous", + "basetype_byvalue", + "basetype_varlength", + "basetype_length", + "talpha_type", + "tnumber_type", + "ensure_tnumber_type", + "ensure_tnumber_basetype", + "tnumber_spantype", + "spatial_basetype", + "tspatial_type", + "ensure_tspatial_type", + "tpoint_type", + "ensure_tpoint_type", + "tgeo_type", + "ensure_tgeo_type", + "tgeo_type_all", + "ensure_tgeo_type_all", + "tgeometry_type", + "ensure_tgeometry_type", + "tgeodetic_type", + "ensure_tgeodetic_type", + "ensure_tnumber_tpoint_type", + "geo_as_ewkb", + "geo_as_ewkt", + "geo_as_geojson", + "geo_as_hexewkb", + "geo_as_text", + "geo_from_ewkb", + "geo_from_geojson", + "geo_from_text", + "geo_out", + "geog_from_hexewkb", + "geog_in", + "geom_from_hexewkb", + "geom_in", + "box3d_make", + "box3d_out", + "gbox_make", + "gbox_out", + "geo_copy", + "geogpoint_make2d", + "geogpoint_make3dz", + "geompoint_make2d", + "geompoint_make3dz", + "geom_to_geog", + "geog_to_geom", + "geo_is_empty", + "geo_is_unitary", + "geo_typename", + "geog_area", + "geog_centroid", + "geog_length", + "geog_perimeter", + "geom_azimuth", + "geom_length", + "geom_perimeter", + "line_numpoints", + "line_point_n", + "geo_reverse", + "geo_round", + "geo_set_srid", + "geo_srid", + "geo_transform", + "geo_transform_pipeline", + "geo_collect_garray", + "geo_makeline_garray", + "geo_num_points", + "geo_num_geos", + "geo_geo_n", + "geo_pointarr", + "geo_points", + "geom_array_union", + "geom_boundary", + "geom_buffer", + "geom_centroid", + "geom_convex_hull", + "geom_difference2d", + "geom_intersection2d", + "geom_intersection2d_coll", + "geom_min_bounding_radius", + "geom_shortestline2d", + "geom_shortestline3d", + "geom_unary_union", + "line_interpolate_point", + "line_locate_point", + "line_substring", + "geog_dwithin", + "geog_intersects", + "geom_contains", + "geom_covers", + "geom_disjoint2d", + "geom_dwithin2d", + "geom_dwithin3d", + "geom_intersects2d", + "geom_intersects3d", + "geom_relate_pattern", + "geom_touches", + "geo_stboxes", + "geo_split_each_n_stboxes", + "geo_split_n_stboxes", + "geog_distance", + "geom_distance2d", + "geom_distance3d", + "geo_equals", + "geo_same", + "geogset_in", + "geomset_in", + "spatialset_as_text", + "spatialset_as_ewkt", + "geoset_make", + "geo_to_set", + "geoset_end_value", + "geoset_start_value", + "geoset_value_n", + "geoset_values", + "contained_geo_set", + "contains_set_geo", + "geo_union_transfn", + "intersection_geo_set", + "intersection_set_geo", + "minus_geo_set", + "minus_set_geo", + "union_geo_set", + "union_set_geo", + "spatialset_set_srid", + "spatialset_srid", + "spatialset_transform", + "spatialset_transform_pipeline", + "stbox_as_hexwkb", + "stbox_as_wkb", + "stbox_from_hexwkb", + "stbox_from_wkb", + "stbox_in", + "stbox_out", + "geo_timestamptz_to_stbox", + "geo_tstzspan_to_stbox", + "stbox_copy", + "stbox_make", + "geo_to_stbox", + "spatialset_to_stbox", + "stbox_to_box3d", + "stbox_to_gbox", + "stbox_to_geo", + "stbox_to_tstzspan", + "timestamptz_to_stbox", + "tstzset_to_stbox", + "tstzspan_to_stbox", + "tstzspanset_to_stbox", + "stbox_area", + "stbox_hash", + "stbox_hash_extended", + "stbox_hast", + "stbox_hasx", + "stbox_hasz", + "stbox_isgeodetic", + "stbox_perimeter", + "stbox_tmax", + "stbox_tmax_inc", + "stbox_tmin", + "stbox_tmin_inc", + "stbox_volume", + "stbox_xmax", + "stbox_xmin", + "stbox_ymax", + "stbox_ymin", + "stbox_zmax", + "stbox_zmin", + "stbox_expand_space", + "stbox_expand_time", + "stbox_get_space", + "stbox_quad_split", + "stbox_round", + "stbox_shift_scale_time", + "stboxarr_round", + "stbox_set_srid", + "stbox_srid", + "stbox_transform", + "stbox_transform_pipeline", + "adjacent_stbox_stbox", + "contained_stbox_stbox", + "contains_stbox_stbox", + "overlaps_stbox_stbox", + "same_stbox_stbox", + "above_stbox_stbox", + "after_stbox_stbox", + "back_stbox_stbox", + "before_stbox_stbox", + "below_stbox_stbox", + "front_stbox_stbox", + "left_stbox_stbox", + "overabove_stbox_stbox", + "overafter_stbox_stbox", + "overback_stbox_stbox", + "overbefore_stbox_stbox", + "overbelow_stbox_stbox", + "overfront_stbox_stbox", + "overleft_stbox_stbox", + "overright_stbox_stbox", + "right_stbox_stbox", + "union_stbox_stbox", + "intersection_stbox_stbox", + "stbox_cmp", + "stbox_eq", + "stbox_ge", + "stbox_gt", + "stbox_le", + "stbox_lt", + "stbox_ne", + "tgeogpoint_from_mfjson", + "tgeogpoint_in", + "tgeography_from_mfjson", + "tgeography_in", + "tgeometry_from_mfjson", + "tgeometry_in", + "tgeompoint_from_mfjson", + "tgeompoint_in", + "tspatial_as_ewkt", + "tspatial_as_text", + "tspatial_out", + "tgeo_from_base_temp", + "tgeoinst_make", + "tgeoseq_from_base_tstzset", + "tgeoseq_from_base_tstzspan", + "tgeoseqset_from_base_tstzspanset", + "tpoint_from_base_temp", + "tpointinst_make", + "tpointseq_from_base_tstzset", + "tpointseq_from_base_tstzspan", + "tpointseq_make_coords", + "tpointseqset_from_base_tstzspanset", + "box3d_to_stbox", + "gbox_to_stbox", + "geomeas_to_tpoint", + "tgeogpoint_to_tgeography", + "tgeography_to_tgeogpoint", + "tgeography_to_tgeometry", + "tgeometry_to_tgeography", + "tgeometry_to_tgeompoint", + "tgeompoint_to_tgeometry", + "tpoint_as_mvtgeom", + "tpoint_tfloat_to_geomeas", + "tspatial_to_stbox", + "bearing_point_point", + "bearing_tpoint_point", + "bearing_tpoint_tpoint", + "tgeo_centroid", + "tgeo_convex_hull", + "tgeo_end_value", + "tgeo_start_value", + "tgeo_traversed_area", + "tgeo_value_at_timestamptz", + "tgeo_value_n", + "tgeo_values", + "tpoint_angular_difference", + "tpoint_azimuth", + "tpoint_cumulative_length", + "tpoint_direction", + "tpoint_get_x", + "tpoint_get_y", + "tpoint_get_z", + "tpoint_is_simple", + "tpoint_length", + "tpoint_speed", + "tpoint_trajectory", + "tpoint_twcentroid", + "tgeo_affine", + "tgeo_scale", + "tpoint_make_simple", + "tspatial_srid", + "tspatial_set_srid", + "tspatial_transform", + "tspatial_transform_pipeline", + "tgeo_at_geom", + "tgeo_at_stbox", + "tgeo_at_value", + "tgeo_minus_geom", + "tgeo_minus_stbox", + "tgeo_minus_value", + "tpoint_at_geom", + "tpoint_at_value", + "tpoint_minus_geom", + "tpoint_minus_value", + "always_eq_geo_tgeo", + "always_eq_tgeo_geo", + "always_eq_tgeo_tgeo", + "always_ne_geo_tgeo", + "always_ne_tgeo_geo", + "always_ne_tgeo_tgeo", + "ever_eq_geo_tgeo", + "ever_eq_tgeo_geo", + "ever_eq_tgeo_tgeo", + "ever_ne_geo_tgeo", + "ever_ne_tgeo_geo", + "ever_ne_tgeo_tgeo", + "teq_geo_tgeo", + "teq_tgeo_geo", + "tne_geo_tgeo", + "tne_tgeo_geo", + "tgeo_stboxes", + "tgeo_space_boxes", + "tgeo_space_time_boxes", + "tgeo_split_each_n_stboxes", + "tgeo_split_n_stboxes", + "adjacent_stbox_tspatial", + "adjacent_tspatial_stbox", + "adjacent_tspatial_tspatial", + "contained_stbox_tspatial", + "contained_tspatial_stbox", + "contained_tspatial_tspatial", + "contains_stbox_tspatial", + "contains_tspatial_stbox", + "contains_tspatial_tspatial", + "overlaps_stbox_tspatial", + "overlaps_tspatial_stbox", + "overlaps_tspatial_tspatial", + "same_stbox_tspatial", + "same_tspatial_stbox", + "same_tspatial_tspatial", + "above_stbox_tspatial", + "above_tspatial_stbox", + "above_tspatial_tspatial", + "after_stbox_tspatial", + "after_tspatial_stbox", + "after_tspatial_tspatial", + "back_stbox_tspatial", + "back_tspatial_stbox", + "back_tspatial_tspatial", + "before_stbox_tspatial", + "before_tspatial_stbox", + "before_tspatial_tspatial", + "below_stbox_tspatial", + "below_tspatial_stbox", + "below_tspatial_tspatial", + "front_stbox_tspatial", + "front_tspatial_stbox", + "front_tspatial_tspatial", + "left_stbox_tspatial", + "left_tspatial_stbox", + "left_tspatial_tspatial", + "overabove_stbox_tspatial", + "overabove_tspatial_stbox", + "overabove_tspatial_tspatial", + "overafter_stbox_tspatial", + "overafter_tspatial_stbox", + "overafter_tspatial_tspatial", + "overback_stbox_tspatial", + "overback_tspatial_stbox", + "overback_tspatial_tspatial", + "overbefore_stbox_tspatial", + "overbefore_tspatial_stbox", + "overbefore_tspatial_tspatial", + "overbelow_stbox_tspatial", + "overbelow_tspatial_stbox", + "overbelow_tspatial_tspatial", + "overfront_stbox_tspatial", + "overfront_tspatial_stbox", + "overfront_tspatial_tspatial", + "overleft_stbox_tspatial", + "overleft_tspatial_stbox", + "overleft_tspatial_tspatial", + "overright_stbox_tspatial", + "overright_tspatial_stbox", + "overright_tspatial_tspatial", + "right_stbox_tspatial", + "right_tspatial_stbox", + "right_tspatial_tspatial", + "acontains_geo_tgeo", + "acontains_tgeo_geo", + "acontains_tgeo_tgeo", + "adisjoint_tgeo_geo", + "adisjoint_tgeo_tgeo", + "adwithin_tgeo_geo", + "adwithin_tgeo_tgeo", + "aintersects_tgeo_geo", + "aintersects_tgeo_tgeo", + "atouches_tgeo_geo", + "atouches_tgeo_tgeo", + "atouches_tpoint_geo", + "econtains_geo_tgeo", + "econtains_tgeo_geo", + "econtains_tgeo_tgeo", + "ecovers_geo_tgeo", + "ecovers_tgeo_geo", + "ecovers_tgeo_tgeo", + "edisjoint_tgeo_geo", + "edisjoint_tgeo_tgeo", + "edwithin_tgeo_geo", + "edwithin_tgeo_tgeo", + "eintersects_tgeo_geo", + "eintersects_tgeo_tgeo", + "etouches_tgeo_geo", + "etouches_tgeo_tgeo", + "etouches_tpoint_geo", + "tcontains_geo_tgeo", + "tcontains_tgeo_geo", + "tcontains_tgeo_tgeo", + "tcovers_geo_tgeo", + "tcovers_tgeo_geo", + "tcovers_tgeo_tgeo", + "tdisjoint_geo_tgeo", + "tdisjoint_tgeo_geo", + "tdisjoint_tgeo_tgeo", + "tdwithin_geo_tgeo", + "tdwithin_tgeo_geo", + "tdwithin_tgeo_tgeo", + "tintersects_geo_tgeo", + "tintersects_tgeo_geo", + "tintersects_tgeo_tgeo", + "ttouches_geo_tgeo", + "ttouches_tgeo_geo", + "ttouches_tgeo_tgeo", + "tdistance_tgeo_geo", + "tdistance_tgeo_tgeo", + "nad_stbox_geo", + "nad_stbox_stbox", + "nad_tgeo_geo", + "nad_tgeo_stbox", + "nad_tgeo_tgeo", + "nai_tgeo_geo", + "nai_tgeo_tgeo", + "shortestline_tgeo_geo", + "shortestline_tgeo_tgeo", + "tpoint_tcentroid_finalfn", + "tpoint_tcentroid_transfn", + "tspatial_extent_transfn", + "stbox_get_space_tile", + "stbox_get_space_time_tile", + "stbox_get_time_tile", + "stbox_space_tiles", + "stbox_space_time_tiles", + "stbox_time_tiles", + "tgeo_space_split", + "tgeo_space_time_split", + "geo_cluster_kmeans", + "geo_cluster_dbscan", + "geo_cluster_intersecting", + "geo_cluster_within", + "gsl_get_generation_rng", + "gsl_get_aggregation_rng", + "datum_ceil", + "datum_degrees", + "datum_float_round", + "datum_floor", + "datum_hash", + "datum_hash_extended", + "datum_radians", + "floatspan_round_set", + "set_in", + "set_out", + "span_in", + "span_out", + "spanset_in", + "spanset_out", + "set_make", + "set_make_exp", + "set_make_free", + "span_make", + "span_set", + "spanset_make_exp", + "spanset_make_free", + "set_span", + "set_spanset", + "value_set_span", + "value_set", + "value_span", + "value_spanset", + "numspan_width", + "numspanset_width", + "set_end_value", + "set_mem_size", + "set_set_subspan", + "set_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_set_intspan", + "intspan_set_floatspan", + "numset_shift_scale", + "numspan_expand", + "numspan_shift_scale", + "numspanset_shift_scale", + "set_compact", + "span_expand", + "spanset_compact", + "tbox_expand_value", + "textcat_textset_text_common", + "tstzspan_set_datespan", + "adjacent_span_value", + "adjacent_spanset_value", + "adjacent_value_spanset", + "contained_value_set", + "contained_value_span", + "contained_value_spanset", + "contains_set_value", + "contains_span_value", + "contains_spanset_value", + "ovadj_span_span", + "left_set_value", + "left_span_value", + "left_spanset_value", + "left_value_set", + "left_value_span", + "left_value_spanset", + "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", + "right_value_set", + "right_set_value", + "right_value_span", + "right_value_spanset", + "right_span_value", + "right_spanset_value", + "bbox_type", + "bbox_get_size", + "bbox_max_dims", + "temporal_bbox_eq", + "temporal_bbox_cmp", + "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", + "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", + "tbox_set", + "float_set_tbox", + "int_set_tbox", + "number_set_tbox", + "number_tbox", + "numset_set_tbox", + "numspan_set_tbox", + "timestamptz_set_tbox", + "tstzset_set_tbox", + "tstzspan_set_tbox", + "tbox_shift_scale_value", + "tbox_expand", + "inter_tbox_tbox", + "tboolinst_in", + "tboolseq_in", + "tboolseqset_in", + "temporal_in", + "temporal_out", + "temparr_out", + "tfloatinst_in", + "tfloatseq_in", + "tfloatseqset_in", + "tinstant_in", + "tinstant_out", + "tintinst_in", + "tintseq_in", + "tintseqset_in", + "tsequence_in", + "tsequence_out", + "tsequenceset_in", + "tsequenceset_out", + "ttextinst_in", + "ttextseq_in", + "ttextseqset_in", + "temporal_from_mfjson", + "temporal_from_base_temp", + "tinstant_copy", + "tinstant_make", + "tinstant_make_free", + "tsequence_copy", + "tsequence_from_base_temp", + "tsequence_from_base_tstzset", + "tsequence_from_base_tstzspan", + "tsequence_make_exp", + "tsequence_make_free", + "tsequenceset_copy", + "tseqsetarr_to_tseqset", + "tsequenceset_from_base_temp", + "tsequenceset_from_base_tstzspanset", + "tsequenceset_make_exp", + "tsequenceset_make_free", + "temporal_set_tstzspan", + "tinstant_set_tstzspan", + "tnumber_set_tbox", + "tnumberinst_set_tbox", + "tnumberseq_set_tbox", + "tnumberseqset_set_tbox", + "tsequence_set_tstzspan", + "tsequenceset_set_tstzspan", + "temporal_end_inst", + "temporal_end_value", + "temporal_inst_n", + "temporal_insts_p", + "temporal_max_inst_p", + "temporal_max_value", + "temporal_mem_size", + "temporal_min_inst_p", + "temporal_min_value", + "temporal_sequences_p", + "temporal_set_bbox", + "temporal_start_inst", + "temporal_start_value", + "temporal_values_p", + "temporal_value_n", + "temporal_values", + "tinstant_hash", + "tinstant_insts", + "tinstant_set_bbox", + "tinstant_time", + "tinstant_timestamps", + "tinstant_value_p", + "tinstant_value", + "tinstant_value_at_timestamptz", + "tinstant_values_p", + "tnumber_set_span", + "tnumberinst_valuespans", + "tnumberseq_avg_val", + "tnumberseq_valuespans", + "tnumberseqset_avg_val", + "tnumberseqset_valuespans", + "tsequence_duration", + "tsequence_end_timestamptz", + "tsequence_hash", + "tsequence_insts_p", + "tsequence_max_inst_p", + "tsequence_max_val", + "tsequence_min_inst_p", + "tsequence_min_val", + "tsequence_segments", + "tsequence_seqs", + "tsequence_start_timestamptz", + "tsequence_time", + "tsequence_timestamps", + "tsequence_value_at_timestamptz", + "tsequence_values_p", + "tsequenceset_duration", + "tsequenceset_end_timestamptz", + "tsequenceset_hash", + "tsequenceset_inst_n", + "tsequenceset_insts_p", + "tsequenceset_max_inst_p", + "tsequenceset_max_val", + "tsequenceset_min_inst_p", + "tsequenceset_min_val", + "tsequenceset_num_instants", + "tsequenceset_num_timestamps", + "tsequenceset_segments", + "tsequenceset_sequences_p", + "tsequenceset_start_timestamptz", + "tsequenceset_time", + "tsequenceset_timestamptz_n", + "tsequenceset_timestamps", + "tsequenceset_value_at_timestamptz", + "tsequenceset_value_n", + "tsequenceset_values_p", + "temporal_restart", + "temporal_tsequence", + "temporal_tsequenceset", + "tinstant_shift_time", + "tinstant_to_tsequence", + "tinstant_to_tsequence_free", + "tinstant_to_tsequenceset", + "tnumber_shift_scale_value", + "tnumberinst_shift_value", + "tnumberseq_shift_scale_value", + "tnumberseqset_shift_scale_value", + "tsequence_restart", + "tsequence_set_interp", + "tsequence_shift_scale_time", + "tsequence_subseq", + "tsequence_to_tinstant", + "tsequence_to_tsequenceset", + "tsequence_to_tsequenceset_free", + "tsequence_to_tsequenceset_interp", + "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", + "tcontseq_after_timestamptz", + "tcontseq_before_timestamptz", + "tcontseq_restrict_minmax", + "tdiscseq_after_timestamptz", + "tdiscseq_before_timestamptz", + "tdiscseq_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_after_timestamptz", + "tinstant_before_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", + "tsequence_at_timestamptz", + "tsequence_restrict_tstzspan", + "tsequence_restrict_tstzspanset", + "tsequenceset_after_timestamptz", + "tsequenceset_before_timestamptz", + "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_ne_base_temporal", + "always_ne_temporal_base", + "always_ge_base_temporal", + "always_ge_temporal_base", + "always_gt_base_temporal", + "always_gt_temporal_base", + "always_le_base_temporal", + "always_le_temporal_base", + "always_lt_base_temporal", + "always_lt_temporal_base", + "ever_eq_base_temporal", + "ever_eq_temporal_base", + "ever_ne_base_temporal", + "ever_ne_temporal_base", + "ever_ge_base_temporal", + "ever_ge_temporal_base", + "ever_gt_base_temporal", + "ever_gt_temporal_base", + "ever_le_base_temporal", + "ever_le_temporal_base", + "ever_lt_base_temporal", + "ever_lt_temporal_base", + "tnumberinst_abs", + "tnumberseq_abs", + "tnumberseq_angular_difference", + "tnumberseq_delta_value", + "tnumberseqset_abs", + "tnumberseqset_angular_difference", + "tnumberseqset_delta_value", + "tdistance_tnumber_number", + "nad_tbox_tbox", + "nad_tnumber_number", + "nad_tnumber_tbox", + "nad_tnumber_tnumber", + "tnumberseq_integral", + "tnumberseq_twavg", + "tnumberseqset_integral", + "tnumberseqset_twavg", + "temporal_compact", + "tsequence_compact", + "tsequenceset_compact", + "temporal_skiplist_make", + "skiplist_search", + "skiplist_free", + "skiplist_splice", + "temporal_skiplist_splice", + "skiplist_values", + "skiplist_keys_values", + "temporal_app_tinst_transfn", + "temporal_app_tseq_transfn", + "span_bins", + "spanset_bins", + "tnumber_value_bins", + "tnumber_value_time_boxes", + "tnumber_value_split", + "tbox_get_value_time_tile", + "tnumber_value_time_split", + "proj_get_context", + "datum_geo_round", + "point_round", + "stbox_set", + "gbox_set_stbox", + "geo_set_stbox", + "geoarr_set_stbox", + "spatial_set_stbox", + "spatialset_set_stbox", + "stbox_set_box3d", + "stbox_set_gbox", + "tstzset_set_stbox", + "tstzspan_set_stbox", + "tstzspanset_set_stbox", + "stbox_expand", + "inter_stbox_stbox", + "stbox_geo", + "tgeogpointinst_in", + "tgeogpointseq_in", + "tgeogpointseqset_in", + "tgeompointinst_in", + "tgeompointseq_in", + "tgeompointseqset_in", + "tgeographyinst_in", + "tgeographyseq_in", + "tgeographyseqset_in", + "tgeometryinst_in", + "tgeometryseq_in", + "tgeometryseqset_in", + "tspatial_set_stbox", + "tgeoinst_set_stbox", + "tspatialseq_set_stbox", + "tspatialseqset_set_stbox", + "tgeo_restrict_geom", + "tgeo_restrict_stbox", + "tgeoinst_restrict_geom", + "tgeoinst_restrict_stbox", + "tgeoseq_restrict_geom", + "tgeoseq_restrict_stbox", + "tgeoseqset_restrict_geom", + "tgeoseqset_restrict_stbox", + "spatial_srid", + "spatial_set_srid", + "tspatialinst_srid", + "tpointseq_azimuth", + "tpointseq_cumulative_length", + "tpointseq_is_simple", + "tpointseq_length", + "tpointseq_linear_trajectory", + "tgeoseq_stboxes", + "tgeoseq_split_n_stboxes", + "tpointseqset_azimuth", + "tpointseqset_cumulative_length", + "tpointseqset_is_simple", + "tpointseqset_length", + "tgeoseqset_stboxes", + "tgeoseqset_split_n_stboxes", + "tpoint_get_coord", + "tgeominst_tgeoginst", + "tgeomseq_tgeogseq", + "tgeomseqset_tgeogseqset", + "tgeom_tgeog", + "tgeo_tpoint", + "tspatialinst_set_srid", + "tpointseq_make_simple", + "tspatialseq_set_srid", + "tpointseqset_make_simple", + "tspatialseqset_set_srid", + "tpointseq_twcentroid", + "tpointseqset_twcentroid", + "npoint_as_ewkt", + "npoint_as_hexwkb", + "npoint_as_text", + "npoint_as_wkb", + "npoint_from_hexwkb", + "npoint_from_wkb", + "npoint_in", + "npoint_out", + "nsegment_in", + "nsegment_out", + "npoint_make", + "nsegment_make", + "geompoint_to_npoint", + "geom_to_nsegment", + "npoint_to_geompoint", + "npoint_to_nsegment", + "npoint_to_stbox", + "nsegment_to_geom", + "nsegment_to_stbox", + "npoint_hash", + "npoint_hash_extended", + "npoint_position", + "npoint_route", + "nsegment_end_position", + "nsegment_route", + "nsegment_start_position", + "route_exists", + "route_geom", + "route_length", + "npoint_round", + "nsegment_round", + "get_srid_ways", + "npoint_srid", + "nsegment_srid", + "npoint_timestamptz_to_stbox", + "npoint_tstzspan_to_stbox", + "npoint_cmp", + "npoint_eq", + "npoint_ge", + "npoint_gt", + "npoint_le", + "npoint_lt", + "npoint_ne", + "npoint_same", + "nsegment_cmp", + "nsegment_eq", + "nsegment_ge", + "nsegment_gt", + "nsegment_le", + "nsegment_lt", + "nsegment_ne", + "npointset_in", + "npointset_out", + "npointset_make", + "npoint_to_set", + "npointset_end_value", + "npointset_routes", + "npointset_start_value", + "npointset_value_n", + "npointset_values", + "contained_npoint_set", + "contains_set_npoint", + "intersection_npoint_set", + "intersection_set_npoint", + "minus_npoint_set", + "minus_set_npoint", + "npoint_union_transfn", + "union_npoint_set", + "union_set_npoint", + "tnpoint_in", + "tnpoint_out", + "tnpointinst_make", + "tgeompoint_to_tnpoint", + "tnpoint_to_tgeompoint", + "tnpoint_cumulative_length", + "tnpoint_length", + "tnpoint_positions", + "tnpoint_route", + "tnpoint_routes", + "tnpoint_speed", + "tnpoint_trajectory", + "tnpoint_twcentroid", + "tnpoint_at_geom", + "tnpoint_at_npoint", + "tnpoint_at_npointset", + "tnpoint_at_stbox", + "tnpoint_minus_geom", + "tnpoint_minus_npoint", + "tnpoint_minus_npointset", + "tnpoint_minus_stbox", + "tdistance_tnpoint_npoint", + "tdistance_tnpoint_point", + "tdistance_tnpoint_tnpoint", + "nad_tnpoint_geo", + "nad_tnpoint_npoint", + "nad_tnpoint_stbox", + "nad_tnpoint_tnpoint", + "nai_tnpoint_geo", + "nai_tnpoint_npoint", + "nai_tnpoint_tnpoint", + "shortestline_tnpoint_geo", + "shortestline_tnpoint_npoint", + "shortestline_tnpoint_tnpoint", + "tnpoint_tcentroid_transfn", + "always_eq_npoint_tnpoint", + "always_eq_tnpoint_npoint", + "always_eq_tnpoint_tnpoint", + "always_ne_npoint_tnpoint", + "always_ne_tnpoint_npoint", + "always_ne_tnpoint_tnpoint", + "ever_eq_npoint_tnpoint", + "ever_eq_tnpoint_npoint", + "ever_eq_tnpoint_tnpoint", + "ever_ne_npoint_tnpoint", + "ever_ne_tnpoint_npoint", + "ever_ne_tnpoint_tnpoint", + "teq_tnpoint_npoint", + "tne_tnpoint_npoint", ]