commit fdd594ca1b4e9967a9cf72562d0481d7c1175b08 · anil.recoil.org/slop

+2 -4

stack/immich/immich.ml

···

       4
       4
        
       

     

       5
       5
        
       (** {1 Types} *)

     

       6
       6
        
       

     

       7
       7
       -
       type 'net t_internal = {

     

       7
       7
       +
       type t = {

     

       8
       8
        
         base_url: string;

     

       9
       9
        
         api_key: string;

     

       10
       10
       -
         requests_session: (float Eio.Time.clock_ty Eio.Resource.t, 'net Eio.Net.ty Eio.Resource.t) Requests.t;

     

       10
       10
       +
         requests_session: Requests.t;

     

       11
       11
        
       }

     

       12
       12
       -
       

     

       13
       13
       -
       type t = [`Generic | `Unix] t_internal

     

       14
       12
        
       

     

       15
       13
        
       type person = {

     

       16
       14
        
         id: string;

+1 -1

stack/immich/immich.mli

···

       37
       37
        
           @return An Immich client configured for the specified instance

     

       38
       38
        
       *)

     

       39
       39
        
       val create :

     

       40
       40
       -
         requests_session:(float Eio.Time.clock_ty Eio.Resource.t, [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t ->

     

       40
       40
       +
         requests_session:Requests.t ->

     

       41
       41
        
         base_url:string ->

     

       42
       42
        
         api_key:string ->

     

       43
       43
        
         t

+2 -4

stack/karakeep/karakeep.ml

···

       27
       27
        
       let json_mems_empty = Jsont.Object ([], Jsont.Meta.none)

     

       28
       28
        
       

     

       29
       29
        
       (** Type representing a Karakeep client session *)

     

       30
       30
       -
       type 'net t_internal = {

     

       30
       30
       +
       type t = {

     

       31
       31
        
         api_key: string;

     

       32
       32
        
         base_url: string;

     

       33
       33
       -
         http_client: (float Eio.Time.clock_ty Eio.Resource.t, 'net Eio.Net.ty Eio.Resource.t) Requests.t;

     

       33
       33
       +
         http_client: Requests.t;

     

       34
       34
        
       }

     

       35
       35
       -
       

     

       36
       36
       -
       type t = [`Generic | `Unix] t_internal

     

       37
       35
        
       

     

       38
       36
        
       (** Create a new Karakeep client *)

     

       39
       37
        
       let create ~sw ~env ~api_key ~base_url : t =

+2 -4

stack/peertubee/peertubee.ml

···

       1
       1
        
       (** PeerTube API client implementation (Eio version) *)

     

       2
       2
        
       

     

       3
       3
        
       (** Type representing a PeerTube client *)

     

       4
       4
       -
       type 'net t_internal = {

     

       4
       4
       +
       type t = {

     

       5
       5
        
         base_url: string;

     

       6
       6
       -
         requests_session: (float Eio.Time.clock_ty Eio.Resource.t, 'net Eio.Net.ty Eio.Resource.t) Requests.t;

     

       6
       6
       +
         requests_session: Requests.t;

     

       7
       7
        
       }

     

       8
       8
       -
       

     

       9
       9
       -
       type t = [`Generic | `Unix] t_internal

     

       10
       8
        
       

     

       11
       9
        
       (** Create a new PeerTube client *)

     

       12
       10
        
       let create ~requests_session ~base_url : t =

+1 -1

stack/peertubee/peertubee.mli

···

       8
       8
        
           @param base_url Base URL of the PeerTube instance

     

       9
       9
        
           @return A PeerTube client configured for the specified instance *)

     

       10
       10
        
       val create :

     

       11
       11
       -
         requests_session:(float Eio.Time.clock_ty Eio.Resource.t, [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t ->

     

       11
       11
       +
         requests_session:Requests.t ->

     

       12
       12
        
         base_url:string ->

     

       13
       13
        
         t

     

       14
       14

+39 -31

stack/requests/lib/requests.ml

···

       22
       22
        
       

     

       23
       23
        
       (* Main API - Session functionality with connection pooling *)

     

       24
       24
        
       

     

       25
       25
       -
       type ('clock, 'net) t = {

     

       25
       25
       +
       (* Internal session type with existential type parameters *)

     

       26
       26
       +
       type ('clock, 'net) session = {

     

       26
       27
        
         sw : Eio.Switch.t;

     

       27
       28
        
         clock : 'clock;

     

       28
       29
        
         net : 'net;

     
···

       46
       47
        
         mutable total_time : float;

     

       47
       48
        
         mutable retries_count : int;

     

       48
       49
        
       }

     

       50
       50
       +
       

     

       51
       51
       +
       (* Public type that hides the existential type parameters.

     

       52
       52
       +
          We constrain the existentials to ensure they satisfy the requirements

     

       53
       53
       +
          of the internal functions. *)

     

       54
       54
       +
       type t = T : ([> float Eio.Time.clock_ty] Eio.Resource.t,

     

       55
       55
       +
                      [> [> `Generic] Eio.Net.ty] Eio.Resource.t) session -> t

     

       49
       56
        
       

     

       50
       57
        
       let create

     

       51
       58
        
           ~sw

     
···

       132
       139
        
               Cookeio.create ()

     

       133
       140
        
         in

     

       134
       141
        
       

     

       135
       135
       -
         {

     

       142
       142
       +
         T {

     

       136
       143
        
           sw;

     

       137
       144
        
           clock;

     

       138
       145
        
           net;

     
···

       155
       162
        
           retries_count = 0;

     

       156
       163
        
         }

     

       157
       164
        
       

     

       158
       158
       -
       let set_default_header t key value =

     

       159
       159
       -
         { t with default_headers = Headers.set key value t.default_headers }

     

       165
       165
       +
       let set_default_header (T t) key value =

     

       166
       166
       +
         T { t with default_headers = Headers.set key value t.default_headers }

     

       160
       167
        
       

     

       161
       161
       -
       let remove_default_header t key =

     

       162
       162
       -
         { t with default_headers = Headers.remove key t.default_headers }

     

       168
       168
       +
       let remove_default_header (T t) key =

     

       169
       169
       +
         T { t with default_headers = Headers.remove key t.default_headers }

     

       163
       170
        
       

     

       164
       164
       -
       let set_auth t auth =

     

       171
       171
       +
       let set_auth (T t) auth =

     

       165
       172
        
         Log.debug (fun m -> m "Setting authentication method");

     

       166
       166
       -
         { t with auth = Some auth }

     

       173
       173
       +
         T { t with auth = Some auth }

     

       167
       174
        
       

     

       168
       168
       -
       let clear_auth t =

     

       175
       175
       +
       let clear_auth (T t) =

     

       169
       176
        
         Log.debug (fun m -> m "Clearing authentication");

     

       170
       170
       -
         { t with auth = None }

     

       177
       177
       +
         T { t with auth = None }

     

       171
       178
        
       

     

       172
       172
       -
       let set_timeout t timeout =

     

       179
       179
       +
       let set_timeout (T t) timeout =

     

       173
       180
        
         Log.debug (fun m -> m "Setting timeout: %a" Timeout.pp timeout);

     

       174
       174
       -
         { t with timeout }

     

       181
       181
       +
         T { t with timeout }

     

       175
       182
        
       

     

       176
       176
       -
       let set_retry t config =

     

       183
       183
       +
       let set_retry (T t) config =

     

       177
       184
        
         Log.debug (fun m -> m "Setting retry config: max_retries=%d" config.Retry.max_retries);

     

       178
       178
       -
         { t with retry = Some config }

     

       185
       185
       +
         T { t with retry = Some config }

     

       179
       186
        
       

     

       180
       180
       -
       let cookies t = t.cookie_jar

     

       181
       181
       -
       let clear_cookies t = Cookeio.clear t.cookie_jar

     

       187
       187
       +
       let cookies (T t) = t.cookie_jar

     

       188
       188
       +
       let clear_cookies (T t) = Cookeio.clear t.cookie_jar

     

       182
       189
        
       

     

       183
       190
        
       (* Internal request function using connection pools *)

     

       184
       191
        
       let make_request_internal t ?headers ?body ?auth ?timeout ?follow_redirects ?max_redirects ~method_ url =

     
···

       360
       367
        
         response

     

       361
       368
        
       

     

       362
       369
        
       (* Public request function - executes synchronously *)

     

       363
       363
       -
       let request t ?headers ?body ?auth ?timeout ?follow_redirects ?max_redirects ~method_ url =

     

       370
       370
       +
       let request (T t) ?headers ?body ?auth ?timeout ?follow_redirects ?max_redirects ~method_ url =

     

       371
       371
       +
         (* Keep t in scope to preserve existential types *)

     

       364
       372
        
         make_request_internal t ?headers ?body ?auth ?timeout

     

       365
       373
        
           ?follow_redirects ?max_redirects ~method_ url

     

       366
       374
        
       

     

       367
       375
        
       (* Convenience methods *)

     

       368
       368
       -
       let get t ?headers ?auth ?timeout ?params url =

     

       376
       376
       +
       let get (T t) ?headers ?auth ?timeout ?params url =

     

       369
       377
        
         let url = match params with

     

       370
       378
        
           | Some p ->

     

       371
       379
        
               let uri = Uri.of_string url in

     
···

       373
       381
        
               Uri.to_string uri

     

       374
       382
        
           | None -> url

     

       375
       383
        
         in

     

       376
       376
       -
         request t ?headers ?auth ?timeout ~method_:`GET url

     

       384
       384
       +
         make_request_internal t ?headers ?auth ?timeout ~method_:`GET url

     

       377
       385
        
       

     

       378
       378
       -
       let post t ?headers ?body ?auth ?timeout url =

     

       379
       379
       -
         request t ?headers ?body ?auth ?timeout ~method_:`POST url

     

       386
       386
       +
       let post (T t) ?headers ?body ?auth ?timeout url =

     

       387
       387
       +
         make_request_internal t ?headers ?body ?auth ?timeout ~method_:`POST url

     

       380
       388
        
       

     

       381
       381
       -
       let put t ?headers ?body ?auth ?timeout url =

     

       382
       382
       -
         request t ?headers ?body ?auth ?timeout ~method_:`PUT url

     

       389
       389
       +
       let put (T t) ?headers ?body ?auth ?timeout url =

     

       390
       390
       +
         make_request_internal t ?headers ?body ?auth ?timeout ~method_:`PUT url

     

       383
       391
        
       

     

       384
       384
       -
       let patch t ?headers ?body ?auth ?timeout url =

     

       385
       385
       -
         request t ?headers ?body ?auth ?timeout ~method_:`PATCH url

     

       392
       392
       +
       let patch (T t) ?headers ?body ?auth ?timeout url =

     

       393
       393
       +
         make_request_internal t ?headers ?body ?auth ?timeout ~method_:`PATCH url

     

       386
       394
        
       

     

       387
       387
       -
       let delete t ?headers ?auth ?timeout url =

     

       388
       388
       -
         request t ?headers ?auth ?timeout ~method_:`DELETE url

     

       395
       395
       +
       let delete (T t) ?headers ?auth ?timeout url =

     

       396
       396
       +
         make_request_internal t ?headers ?auth ?timeout ~method_:`DELETE url

     

       389
       397
        
       

     

       390
       390
       -
       let head t ?headers ?auth ?timeout url =

     

       391
       391
       -
         request t ?headers ?auth ?timeout ~method_:`HEAD url

     

       398
       398
       +
       let head (T t) ?headers ?auth ?timeout url =

     

       399
       399
       +
         make_request_internal t ?headers ?auth ?timeout ~method_:`HEAD url

     

       392
       400
        
       

     

       393
       393
       -
       let options t ?headers ?auth ?timeout url =

     

       394
       394
       -
         request t ?headers ?auth ?timeout ~method_:`OPTIONS url

     

       401
       401
       +
       let options (T t) ?headers ?auth ?timeout url =

     

       402
       402
       +
         make_request_internal t ?headers ?auth ?timeout ~method_:`OPTIONS url

     

       395
       403
        
       

     

       396
       404
        
       (* Cmdliner integration module *)

     

       397
       405
        
       module Cmd = struct

+33 -23

stack/requests/lib/requests.mli

···

       132
       132
        
           Use Eio.Fiber.both or Eio.Fiber.all for concurrent execution.

     

       133
       133
        
       *)

     

       134
       134
        
       

     

       135
       135
       -
       type ('clock, 'net) t

     

       135
       135
       +
       type t

     

       136
       136
        
       (** A stateful HTTP client that maintains cookies, auth, configuration, and

     

       137
       137
       -
           connection pools across requests. *)

     

       137
       137
       +
           connection pools across requests. The internal clock and network types are

     

       138
       138
       +
           hidden from external users. *)

     

       138
       139
        
       

     

       139
       140
        
       (** {2 Creation and Configuration} *)

     

       140
       141
        
       

     

       141
       142
        
       val create :

     

       142
       143
        
         sw:Eio.Switch.t ->

     

       143
       143
       -
         ?http_pool:('clock Eio.Time.clock, 'net Eio.Net.t) Conpool.t ->

     

       144
       144
       -
         ?https_pool:('clock Eio.Time.clock, 'net Eio.Net.t) Conpool.t ->

     

       144
       144
       +
         ?http_pool:(([> float Eio.Time.clock_ty] as 'clock) Eio.Resource.t,

     

       145
       145
       +
                     ([> [> `Generic] Eio.Net.ty] as 'net) Eio.Resource.t) Conpool.t ->

     

       146
       146
       +
         ?https_pool:('clock Eio.Resource.t, 'net Eio.Resource.t) Conpool.t ->

     

       145
       147
        
         ?cookie_jar:Cookeio.jar ->

     

       146
       148
        
         ?default_headers:Headers.t ->

     

       147
       149
        
         ?auth:Auth.t ->

     
···

       157
       159
        
         ?persist_cookies:bool ->

     

       158
       160
        
         ?xdg:Xdge.t ->

     

       159
       161
        
         < clock: 'clock Eio.Resource.t; net: 'net Eio.Resource.t; fs: Eio.Fs.dir_ty Eio.Path.t; .. > ->

     

       160
       160
       -
         ('clock Eio.Resource.t, 'net Eio.Resource.t) t

     

       162
       162
       +
         t

     

       161
       163
        
       (** Create a new requests instance with persistent state and connection pooling.

     

       162
       164
        
           All resources are bound to the provided switch and will be cleaned up automatically.

     

       163
       165
        
       

     
···

       185
       187
        
       

     

       186
       188
        
       (** {2 Configuration Management} *)

     

       187
       189
        
       

     

       188
       188
       -
       val set_default_header : ('clock, 'net) t -> string -> string -> ('clock, 'net) t

     

       190
       190
       +
       val set_default_header : t -> string -> string -> t

     

       189
       191
        
       (** Add or update a default header. Returns a new session with the updated header.

     

       190
       192
        
           The original session's connection pools are shared. *)

     

       191
       193
        
       

     

       192
       192
       -
       val remove_default_header : ('clock, 'net) t -> string -> ('clock, 'net) t

     

       194
       194
       +
       val remove_default_header : t -> string -> t

     

       193
       195
        
       (** Remove a default header. Returns a new session without the header. *)

     

       194
       196
        
       

     

       195
       195
       -
       val set_auth : ('clock, 'net) t -> Auth.t -> ('clock, 'net) t

     

       197
       197
       +
       val set_auth : t -> Auth.t -> t

     

       196
       198
        
       (** Set default authentication. Returns a new session with auth configured. *)

     

       197
       199
        
       

     

       198
       198
       -
       val clear_auth : ('clock, 'net) t -> ('clock, 'net) t

     

       200
       200
       +
       val clear_auth : t -> t

     

       199
       201
        
       (** Clear authentication. Returns a new session without auth. *)

     

       200
       202
        
       

     

       201
       201
       -
       val set_timeout : ('clock, 'net) t -> Timeout.t -> ('clock, 'net) t

     

       203
       203
       +
       val set_timeout : t -> Timeout.t -> t

     

       202
       204
        
       (** Set default timeout. Returns a new session with the timeout configured. *)

     

       203
       205
        
       

     

       204
       204
       -
       val set_retry : ('clock, 'net) t -> Retry.config -> ('clock, 'net) t

     

       206
       206
       +
       val set_retry : t -> Retry.config -> t

     

       205
       207
        
       (** Set retry configuration. Returns a new session with retry configured. *)

     

       206
       208
        
       

     

       207
       209
        
       (** {2 Request Methods}

     
···

       282
       284
        
       *)

     

       283
       285
        
       

     

       284
       286
        
       val request :

     

       285
       285
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       287
       287
       +
         t ->

     

       286
       288
        
         ?headers:Headers.t ->

     

       287
       289
        
         ?body:Body.t ->

     

       288
       290
        
         ?auth:Auth.t ->

     
···

       295
       297
        
       (** Make a concurrent HTTP request *)

     

       296
       298
        
       

     

       297
       299
        
       val get :

     

       298
       298
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       300
       300
       +
         t ->

     

       299
       301
        
         ?headers:Headers.t ->

     

       300
       302
        
         ?auth:Auth.t ->

     

       301
       303
        
         ?timeout:Timeout.t ->

     
···

       305
       307
        
       (** Concurrent GET request *)

     

       306
       308
        
       

     

       307
       309
        
       val post :

     

       308
       308
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       310
       310
       +
         t ->

     

       309
       311
        
         ?headers:Headers.t ->

     

       310
       312
        
         ?body:Body.t ->

     

       311
       313
        
         ?auth:Auth.t ->

     
···

       315
       317
        
       (** Concurrent POST request *)

     

       316
       318
        
       

     

       317
       319
        
       val put :

     

       318
       318
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       320
       320
       +
         t ->

     

       319
       321
        
         ?headers:Headers.t ->

     

       320
       322
        
         ?body:Body.t ->

     

       321
       323
        
         ?auth:Auth.t ->

     
···

       325
       327
        
       (** Concurrent PUT request *)

     

       326
       328
        
       

     

       327
       329
        
       val patch :

     

       328
       328
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       330
       330
       +
         t ->

     

       329
       331
        
         ?headers:Headers.t ->

     

       330
       332
        
         ?body:Body.t ->

     

       331
       333
        
         ?auth:Auth.t ->

     
···

       335
       337
        
       (** Concurrent PATCH request *)

     

       336
       338
        
       

     

       337
       339
        
       val delete :

     

       338
       338
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       340
       340
       +
         t ->

     

       339
       341
        
         ?headers:Headers.t ->

     

       340
       342
        
         ?auth:Auth.t ->

     

       341
       343
        
         ?timeout:Timeout.t ->

     
···

       344
       346
        
       (** Concurrent DELETE request *)

     

       345
       347
        
       

     

       346
       348
        
       val head :

     

       347
       347
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       349
       349
       +
         t ->

     

       348
       350
        
         ?headers:Headers.t ->

     

       349
       351
        
         ?auth:Auth.t ->

     

       350
       352
        
         ?timeout:Timeout.t ->

     
···

       353
       355
        
       (** Concurrent HEAD request *)

     

       354
       356
        
       

     

       355
       357
        
       val options :

     

       356
       356
       -
         (_ Eio.Time.clock, _ Eio.Net.t) t ->

     

       358
       358
       +
         t ->

     

       357
       359
        
         ?headers:Headers.t ->

     

       358
       360
        
         ?auth:Auth.t ->

     

       359
       361
        
         ?timeout:Timeout.t ->

     
···

       363
       365
        
       

     

       364
       366
        
       (** {2 Cookie Management} *)

     

       365
       367
        
       

     

       366
       366
       -
       val cookies : ('clock, 'net) t -> Cookeio.jar

     

       368
       368
       +
       val cookies : t -> Cookeio.jar

     

       367
       369
        
       (** Get the cookie jar for direct manipulation *)

     

       368
       370
        
       

     

       369
       369
       -
       val clear_cookies : ('clock, 'net) t -> unit

     

       371
       371
       +
       val clear_cookies : t -> unit

     

       370
       372
        
       (** Clear all cookies *)

     

       371
       373
        
       

     

       372
       374
        
       (** {1 Cmdliner Integration} *)

     
···

       391
       393
        
           user_agent : string option;  (** User-Agent header *)

     

       392
       394
        
         }

     

       393
       395
        
       

     

       394
       394
       -
         val create : config -> < clock: ([> float Eio.Time.clock_ty ] as 'clock) Eio.Resource.t; net: ([> [>`Generic] Eio.Net.ty ] as 'net) Eio.Resource.t; fs: Eio.Fs.dir_ty Eio.Path.t; .. > -> Eio.Switch.t -> ('clock Eio.Resource.t, 'net Eio.Resource.t) t

     

       396
       396
       +
         val create : config ->

     

       397
       397
       +
           < clock: [> float Eio.Time.clock_ty] Eio.Resource.t;

     

       398
       398
       +
             net: [> [> `Generic] Eio.Net.ty] Eio.Resource.t;

     

       399
       399
       +
             fs: Eio.Fs.dir_ty Eio.Path.t; .. > ->

     

       400
       400
       +
           Eio.Switch.t -> t

     

       395
       401
        
         (** [create config env sw] creates a requests instance from command-line configuration *)

     

       396
       402
        
       

     

       397
       403
        
         (** {2 Individual Terms} *)

     
···

       454
       460
        
               Cmd.eval cmd

     

       455
       461
        
             ]} *)

     

       456
       462
        
       

     

       457
       457
       -
         val requests_term : string -> < clock: ([> float Eio.Time.clock_ty ] as 'clock) Eio.Resource.t; net: ([> [>`Generic] Eio.Net.ty ] as 'net) Eio.Resource.t; fs: Eio.Fs.dir_ty Eio.Path.t; .. > -> Eio.Switch.t -> ('clock Eio.Resource.t, 'net Eio.Resource.t) t Cmdliner.Term.t

     

       463
       463
       +
         val requests_term : string ->

     

       464
       464
       +
           < clock: [> float Eio.Time.clock_ty] Eio.Resource.t;

     

       465
       465
       +
             net: [> [> `Generic] Eio.Net.ty] Eio.Resource.t;

     

       466
       466
       +
             fs: Eio.Fs.dir_ty Eio.Path.t; .. > ->

     

       467
       467
       +
           Eio.Switch.t -> t Cmdliner.Term.t

     

       458
       468
        
         (** [requests_term app_name env sw] creates a term that directly produces a requests instance.

     

       459
       469
        
       

     

       460
       470
        
             This is a convenience function that combines configuration parsing

+12 -12

stack/requests_json_api/lib/requests_json_api.mli

···

       26
       26
        
       

     

       27
       27
        
       (** {1 JSON Request Helpers} *)

     

       28
       28
        
       

     

       29
       29
       -
       val get_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a

     

       29
       29
       +
       val get_json_exn : Requests.t -> string -> 'a Jsont.t -> 'a

     

       30
       30
        
       (** [get_json_exn session url decoder] makes a GET request, checks status is 2xx,

     

       31
       31
        
           reads and parses JSON body using the provided Jsont decoder.

     

       32
       32
        
           Raises [Failure] on any error (HTTP, network, or JSON parse). *)

     

       33
       33
        
       

     

       34
       34
       -
       val get_json : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t ->

     

       34
       34
       +
       val get_json : Requests.t -> string -> 'a Jsont.t ->

     

       35
       35
        
         ('a, [> `Http of int * string | `Json_error of string]) result

     

       36
       36
        
       (** Like [get_json_exn] but returns [Result] instead of raising exceptions.

     

       37
       37
        
           Returns [Ok parsed_value] on success, or [Error] with details on failure. *)

     

       38
       38
        
       

     

       39
       39
       -
       val post_json : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a -> Requests.Response.t

     

       39
       39
       +
       val post_json : Requests.t -> string -> 'a Jsont.t -> 'a -> Requests.Response.t

     

       40
       40
        
       (** [post_json session url codec value] encodes [value] using the Jsont codec and POSTs it to the URL.

     

       41
       41
        
           Returns the raw response for custom handling. *)

     

       42
       42
        
       

     

       43
       43
       -
       val post_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       43
       43
       +
       val post_json_exn : Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       44
       44
        
       (** Like [post_json] but checks status is 2xx and returns the response body as a string.

     

       45
       45
        
           Raises [Failure] on non-2xx status. *)

     

       46
       46
        
       

     

       47
       47
       -
       val post_json_result : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a ->

     

       47
       47
       +
       val post_json_result : Requests.t -> string -> 'a Jsont.t -> 'a ->

     

       48
       48
        
         (string, int * string) result

     

       49
       49
        
       (** Like [post_json_exn] but returns [Result] instead of raising.

     

       50
       50
        
           [Ok body] on 2xx status, [Error (status, body)] otherwise. *)

     

       51
       51
        
       

     

       52
       52
       -
       val post_json_decode_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string ->

     

       52
       52
       +
       val post_json_decode_exn : Requests.t -> string ->

     

       53
       53
        
         req:'a Jsont.t -> 'a -> resp:'b Jsont.t -> 'b

     

       54
       54
        
       (** [post_json_decode_exn session url ~req req_value ~resp] encodes [req_value] using the [req] codec,

     

       55
       55
        
           POSTs it to the URL, checks status is 2xx, and decodes the response using the [resp] codec.

     

       56
       56
        
           Raises [Failure] on any error. *)

     

       57
       57
        
       

     

       58
       58
       -
       val post_json_decode : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string ->

     

       58
       58
       +
       val post_json_decode : Requests.t -> string ->

     

       59
       59
        
         req:'a Jsont.t -> 'a -> resp:'b Jsont.t ->

     

       60
       60
        
         ('b, [> `Http of int * string | `Json_error of string]) result

     

       61
       61
        
       (** Like [post_json_decode_exn] but returns [Result] instead of raising. *)

     

       62
       62
        
       

     

       63
       63
       -
       val put_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       63
       63
       +
       val put_json_exn : Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       64
       64
        
       (** [put_json_exn session url codec value] encodes [value] and PUTs it to the URL.

     

       65
       65
        
           Returns response body. Raises [Failure] on non-2xx status. *)

     

       66
       66
        
       

     

       67
       67
       -
       val put_json_decode_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string ->

     

       67
       67
       +
       val put_json_decode_exn : Requests.t -> string ->

     

       68
       68
        
         req:'a Jsont.t -> 'a -> resp:'b Jsont.t -> 'b

     

       69
       69
        
       (** Like [post_json_decode_exn] but uses PUT method. *)

     

       70
       70
        
       

     

       71
       71
       -
       val patch_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       71
       71
       +
       val patch_json_exn : Requests.t -> string -> 'a Jsont.t -> 'a -> string

     

       72
       72
        
       (** [patch_json_exn session url codec value] encodes [value] and PATCHes it to the URL.

     

       73
       73
        
           Returns response body. Raises [Failure] on non-2xx status. *)

     

       74
       74
        
       

     

       75
       75
       -
       val delete_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> string

     

       75
       75
       +
       val delete_json_exn : Requests.t -> string -> string

     

       76
       76
        
       (** [delete_json_exn session url] makes a DELETE request.

     

       77
       77
        
           Returns response body. Raises [Failure] on non-2xx status. *)

     

       78
       78
        
       

     
···

       91
       91
        
       (** [read_body response] reads the entire response body as a string.

     

       92
       92
        
           Equivalent to [Requests.Response.body response |> Eio.Flow.read_all] *)

     

       93
       93
        
       

     

       94
       94
       -
       val get_result : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> (string, int * string) result

     

       94
       94
       +
       val get_result : Requests.t -> string -> (string, int * string) result

     

       95
       95
        
       (** [get_result session url] makes a GET request and returns the result.

     

       96
       96
        
           Returns [Ok body] on 2xx status, [Error (status, body)] otherwise. *)

     

       97
       97

+1 -2

stack/river/lib/client.ml

···

       21
       21
        
       module Log = (val Logs.src_log src : Logs.LOG)

     

       22
       22
        
       

     

       23
       23
        
       type t = {

     

       24
       24
       -
         session : (float Eio.Time.clock_ty Eio.Resource.t,

     

       25
       25
       -
                    [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t;

     

       24
       24
       +
         session : Requests.t;

     

       26
       25
        
       }

     

       27
       26
        
       

     

       28
       27
        
       let create ~sw (env : _ ) =

+1 -2

stack/river/lib/client.mli

···

       54
       54
        
       (** [session t] returns the underlying Requests session.

     

       55
       55
        
       

     

       56
       56
        
           This is used internally by River's HTTP functions. *)

     

       57
       57
       -
       val session : t -> (float Eio.Time.clock_ty Eio.Resource.t,

     

       58
       58
       -
                           [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t

     

       57
       57
       +
       val session : t -> Requests.t

+3 -6

stack/typesense-client/typesense_client.ml

···

       6
       6
        
         api_key : string;

     

       7
       7
        
       }

     

       8
       8
        
       

     

       9
       9
       -
       (** Internal polymorphic type for the client *)

     

       10
       10
       -
       type 'net t_internal = {

     

       9
       9
       +
       (** Client type *)

     

       10
       10
       +
       type t = {

     

       11
       11
        
         config: config;

     

       12
       12
       -
         requests_session: (float Eio.Time.clock_ty Eio.Resource.t, 'net Eio.Net.ty Eio.Resource.t) Requests.t;

     

       12
       12
       +
         requests_session: Requests.t;

     

       13
       13
        
       }

     

       14
       14
       -
       

     

       15
       15
       -
       (** Public client type *)

     

       16
       16
       -
       type t = [`Generic | `Unix] t_internal

     

       17
       14
        
       

     

       18
       15
        
       (** Create a new Typesense client *)

     

       19
       16
        
       let create ~requests_session ~config : t =

+1 -1

stack/typesense-client/typesense_client.mli

···

       14
       14
        
           @param config Configuration with endpoint and API key

     

       15
       15
        
           @return A client instance *)

     

       16
       16
        
       val create :

     

       17
       17
       -
         requests_session:(float Eio.Time.clock_ty Eio.Resource.t, [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t ->

     

       17
       17
       +
         requests_session:Requests.t ->

     

       18
       18
        
         config:config ->

     

       19
       19
        
         t

     

       20
       20

+2 -2

stack/zotero-translation/zotero_translation.ml

···

       97
       97
        
         | true -> Uri.of_string (base_uri ^ "import")

     

       98
       98
        
         | false -> Uri.of_string (base_uri ^ "/import")

     

       99
       99
        
       

     

       100
       100
       -
       type ('clock, 'net) t = {

     

       100
       100
       +
       type t = {

     

       101
       101
        
         base_uri: string;

     

       102
       102
       -
         requests_session: ('clock, 'net) Requests.t;

     

       102
       102
       +
         requests_session: Requests.t;

     

       103
       103
        
       }

     

       104
       104
        
       

     

       105
       105
        
       let create ~requests_session base_uri =

+8 -8

stack/zotero-translation/zotero_translation.mli

···

       1
       1
        
       (** {1 Interface to the Zotero Translation Server} *)

     

       2
       2
        
       

     

       3
       3
       -
       type ('clock, 'net) t

     

       3
       3
       +
       type t

     

       4
       4
        
       

     

       5
       5
        
       type format =

     

       6
       6
        
         | Bibtex

     
···

       28
       28
        
           @param requests_session Shared Requests session for connection pooling.

     

       29
       29
        
           @param base_uri Base URI of the Zotero translation server (e.g., "http://localhost:1969"). *)

     

       30
       30
        
       val create :

     

       31
       31
       -
         requests_session:('clock Eio.Resource.t, 'net Eio.Resource.t) Requests.t ->

     

       32
       32
       -
         string -> ('clock Eio.Resource.t, 'net Eio.Resource.t) t

     

       31
       31
       +
         requests_session:Requests.t ->

     

       32
       32
       +
         string -> t

     

       33
       33
        
       

     

       34
       34
       -
       val resolve_doi: ([> float Eio.Time.clock_ty ] Eio.Resource.t, [> [> `Generic ] Eio.Net.ty ] Eio.Resource.t) t ->

     

       34
       34
       +
       val resolve_doi: t ->

     

       35
       35
        
         string -> (Jsont.json, [>`Msg of string]) result

     

       36
       36
        
       

     

       37
       37
       -
       val resolve_url: ([> float Eio.Time.clock_ty ] Eio.Resource.t, [> [> `Generic ] Eio.Net.ty ] Eio.Resource.t) t ->

     

       37
       37
       +
       val resolve_url: t ->

     

       38
       38
        
         string -> (Jsont.json, [>`Msg of string]) result

     

       39
       39
        
       

     

       40
       40
       -
       val search_id: ([> float Eio.Time.clock_ty ] Eio.Resource.t, [> [> `Generic ] Eio.Net.ty ] Eio.Resource.t) t ->

     

       40
       40
       +
       val search_id: t ->

     

       41
       41
        
         string -> (Jsont.json, [>`Msg of string]) result

     

       42
       42
        
       

     

       43
       43
       -
       val export: ([> float Eio.Time.clock_ty ] Eio.Resource.t, [> [> `Generic ] Eio.Net.ty ] Eio.Resource.t) t ->

     

       43
       43
       +
       val export: t ->

     

       44
       44
        
         format -> Jsont.json -> (string, [>`Msg of string]) result

     

       45
       45
        
       

     

       46
       46
       -
       val json_of_doi : ([> float Eio.Time.clock_ty ] Eio.Resource.t, [> [> `Generic ] Eio.Net.ty ] Eio.Resource.t) t ->

     

       46
       46
       +
       val json_of_doi : t ->

     

       47
       47
        
         slug:string -> string -> Jsont.object'

+1 -2

stack/zulip/lib/zulip/lib/client.ml

···

       4
       4
        
       

     

       5
       5
        
       type t = {

     

       6
       6
        
         auth : Auth.t;

     

       7
       7
       -
         session : (float Eio.Time.clock_ty Eio.Resource.t,

     

       8
       8
       -
                    [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t;

     

       7
       7
       +
         session : Requests.t;

     

       9
       8
        
       }

     

       10
       9
        
       

     

       11
       10
        
       let create ~sw env auth =