commit fdd594ca1b4e9967a9cf72562d0481d7c1175b08 · anil.recoil.org/slop

+2 -4

stack/immich/immich.ml

···

       4
        
       

     

       5
        
       (** {1 Types} *)

     

       6
        
       

     

       7
       -
       type 'net t_internal = {

     

       8
        
         base_url: string;

     

       9
        
         api_key: string;

     

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

     

       11
        
       }

     

       12
       -
       

     

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

     

       14
        
       

     

       15
        
       type person = {

     

       16
        
         id: string;

···

       4
        
       

     

       5
        
       (** {1 Types} *)

     

       6
        
       

     

       7
       +
       type t = {

     

       8
        
         base_url: string;

     

       9
        
         api_key: string;

     

       10
       +
         requests_session: Requests.t;

     

       11
        
       }

     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
        
       type person = {

     

       14
        
         id: string;

+1 -1

stack/immich/immich.mli

···

       37
        
           @return An Immich client configured for the specified instance

     

       38
        
       *)

     

       39
        
       val create :

     

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

     

       41
        
         base_url:string ->

     

       42
        
         api_key:string ->

     

       43
        
         t

···

       37
        
           @return An Immich client configured for the specified instance

     

       38
        
       *)

     

       39
        
       val create :

     

       40
       +
         requests_session:Requests.t ->

     

       41
        
         base_url:string ->

     

       42
        
         api_key:string ->

     

       43
        
         t

+2 -4

stack/karakeep/karakeep.ml

···

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

     

       28
        
       

     

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

     

       30
       -
       type 'net t_internal = {

     

       31
        
         api_key: string;

     

       32
        
         base_url: string;

     

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

     

       34
        
       }

     

       35
       -
       

     

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

     

       37
        
       

     

       38
        
       (** Create a new Karakeep client *)

     

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

···

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

     

       28
        
       

     

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

     

       30
       +
       type t = {

     

       31
        
         api_key: string;

     

       32
        
         base_url: string;

     

       33
       +
         http_client: Requests.t;

     

       34
        
       }

     

       0
        
       
     

       0
        
       
     

       35
        
       

     

       36
        
       (** Create a new Karakeep client *)

     

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

+2 -4

stack/peertubee/peertubee.ml

···

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

     

       2
        
       

     

       3
        
       (** Type representing a PeerTube client *)

     

       4
       -
       type 'net t_internal = {

     

       5
        
         base_url: string;

     

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

     

       7
        
       }

     

       8
       -
       

     

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

     

       10
        
       

     

       11
        
       (** Create a new PeerTube client *)

     

       12
        
       let create ~requests_session ~base_url : t =

···

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

     

       2
        
       

     

       3
        
       (** Type representing a PeerTube client *)

     

       4
       +
       type t = {

     

       5
        
         base_url: string;

     

       6
       +
         requests_session: Requests.t;

     

       7
        
       }

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       (** Create a new PeerTube client *)

     

       10
        
       let create ~requests_session ~base_url : t =

+1 -1

stack/peertubee/peertubee.mli

···

       8
        
           @param base_url Base URL of the PeerTube instance

     

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

     

       10
        
       val create :

     

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

     

       12
        
         base_url:string ->

     

       13
        
         t

     

       14

···

       8
        
           @param base_url Base URL of the PeerTube instance

     

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

     

       10
        
       val create :

     

       11
       +
         requests_session:Requests.t ->

     

       12
        
         base_url:string ->

     

       13
        
         t

     

       14

+39 -31

stack/requests/lib/requests.ml

···

       22
        
       

     

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

     

       24
        
       

     

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

     

       0
        
       
     

       26
        
         sw : Eio.Switch.t;

     

       27
        
         clock : 'clock;

     

       28
        
         net : 'net;

     
···

       46
        
         mutable total_time : float;

     

       47
        
         mutable retries_count : int;

     

       48
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       49
        
       

     

       50
        
       let create

     

       51
        
           ~sw

     
···

       132
        
               Cookeio.create ()

     

       133
        
         in

     

       134
        
       

     

       135
       -
         {

     

       136
        
           sw;

     

       137
        
           clock;

     

       138
        
           net;

     
···

       155
        
           retries_count = 0;

     

       156
        
         }

     

       157
        
       

     

       158
       -
       let set_default_header t key value =

     

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

     

       160
        
       

     

       161
       -
       let remove_default_header t key =

     

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

     

       163
        
       

     

       164
       -
       let set_auth t auth =

     

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

     

       166
       -
         { t with auth = Some auth }

     

       167
        
       

     

       168
       -
       let clear_auth t =

     

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

     

       170
       -
         { t with auth = None }

     

       171
        
       

     

       172
       -
       let set_timeout t timeout =

     

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

     

       174
       -
         { t with timeout }

     

       175
        
       

     

       176
       -
       let set_retry t config =

     

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

     

       178
       -
         { t with retry = Some config }

     

       179
        
       

     

       180
       -
       let cookies t = t.cookie_jar

     

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

     

       182
        
       

     

       183
        
       (* Internal request function using connection pools *)

     

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

     
···

       360
        
         response

     

       361
        
       

     

       362
        
       (* Public request function - executes synchronously *)

     

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

     

       0
        
       
     

       364
        
         make_request_internal t ?headers ?body ?auth ?timeout

     

       365
        
           ?follow_redirects ?max_redirects ~method_ url

     

       366
        
       

     

       367
        
       (* Convenience methods *)

     

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

     

       369
        
         let url = match params with

     

       370
        
           | Some p ->

     

       371
        
               let uri = Uri.of_string url in

     
···

       373
        
               Uri.to_string uri

     

       374
        
           | None -> url

     

       375
        
         in

     

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

     

       377
        
       

     

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

     

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

     

       380
        
       

     

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

     

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

     

       383
        
       

     

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

     

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

     

       386
        
       

     

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

     

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

     

       389
        
       

     

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

     

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

     

       392
        
       

     

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

     

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

     

       395
        
       

     

       396
        
       (* Cmdliner integration module *)

     

       397
        
       module Cmd = struct

···

       22
        
       

     

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

     

       24
        
       

     

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

     

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

     

       27
        
         sw : Eio.Switch.t;

     

       28
        
         clock : 'clock;

     

       29
        
         net : 'net;

     
···

       47
        
         mutable total_time : float;

     

       48
        
         mutable retries_count : int;

     

       49
        
       }

     

       50
       +
       

     

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

     

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

     

       53
       +
          of the internal functions. *)

     

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

     

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

     

       56
        
       

     

       57
        
       let create

     

       58
        
           ~sw

     
···

       139
        
               Cookeio.create ()

     

       140
        
         in

     

       141
        
       

     

       142
       +
         T {

     

       143
        
           sw;

     

       144
        
           clock;

     

       145
        
           net;

     
···

       162
        
           retries_count = 0;

     

       163
        
         }

     

       164
        
       

     

       165
       +
       let set_default_header (T t) key value =

     

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

     

       167
        
       

     

       168
       +
       let remove_default_header (T t) key =

     

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

     

       170
        
       

     

       171
       +
       let set_auth (T t) auth =

     

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

     

       173
       +
         T { t with auth = Some auth }

     

       174
        
       

     

       175
       +
       let clear_auth (T t) =

     

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

     

       177
       +
         T { t with auth = None }

     

       178
        
       

     

       179
       +
       let set_timeout (T t) timeout =

     

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

     

       181
       +
         T { t with timeout }

     

       182
        
       

     

       183
       +
       let set_retry (T t) config =

     

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

     

       185
       +
         T { t with retry = Some config }

     

       186
        
       

     

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

     

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

     

       189
        
       

     

       190
        
       (* Internal request function using connection pools *)

     

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

     
···

       367
        
         response

     

       368
        
       

     

       369
        
       (* Public request function - executes synchronously *)

     

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

     

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

     

       372
        
         make_request_internal t ?headers ?body ?auth ?timeout

     

       373
        
           ?follow_redirects ?max_redirects ~method_ url

     

       374
        
       

     

       375
        
       (* Convenience methods *)

     

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

     

       377
        
         let url = match params with

     

       378
        
           | Some p ->

     

       379
        
               let uri = Uri.of_string url in

     
···

       381
        
               Uri.to_string uri

     

       382
        
           | None -> url

     

       383
        
         in

     

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

     

       385
        
       

     

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

     

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

     

       388
        
       

     

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

     

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

     

       391
        
       

     

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

     

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

     

       394
        
       

     

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

     

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

     

       397
        
       

     

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

     

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

     

       400
        
       

     

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

     

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

     

       403
        
       

     

       404
        
       (* Cmdliner integration module *)

     

       405
        
       module Cmd = struct

+33 -23

stack/requests/lib/requests.mli

···

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

     

       133
        
       *)

     

       134
        
       

     

       135
       -
       type ('clock, 'net) t

     

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

     

       137
       -
           connection pools across requests. *)

     

       0
        
       
     

       138
        
       

     

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

     

       140
        
       

     

       141
        
       val create :

     

       142
        
         sw:Eio.Switch.t ->

     

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

     

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

     

       0
        
       
     

       145
        
         ?cookie_jar:Cookeio.jar ->

     

       146
        
         ?default_headers:Headers.t ->

     

       147
        
         ?auth:Auth.t ->

     
···

       157
        
         ?persist_cookies:bool ->

     

       158
        
         ?xdg:Xdge.t ->

     

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

     

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

     

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

     

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

     

       163
        
       

     
···

       185
        
       

     

       186
        
       (** {2 Configuration Management} *)

     

       187
        
       

     

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

     

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

     

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

     

       191
        
       

     

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

     

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

     

       194
        
       

     

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

     

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

     

       197
        
       

     

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

     

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

     

       200
        
       

     

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

     

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

     

       203
        
       

     

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

     

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

     

       206
        
       

     

       207
        
       (** {2 Request Methods}

     
···

       282
        
       *)

     

       283
        
       

     

       284
        
       val request :

     

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

     

       286
        
         ?headers:Headers.t ->

     

       287
        
         ?body:Body.t ->

     

       288
        
         ?auth:Auth.t ->

     
···

       295
        
       (** Make a concurrent HTTP request *)

     

       296
        
       

     

       297
        
       val get :

     

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

     

       299
        
         ?headers:Headers.t ->

     

       300
        
         ?auth:Auth.t ->

     

       301
        
         ?timeout:Timeout.t ->

     
···

       305
        
       (** Concurrent GET request *)

     

       306
        
       

     

       307
        
       val post :

     

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

     

       309
        
         ?headers:Headers.t ->

     

       310
        
         ?body:Body.t ->

     

       311
        
         ?auth:Auth.t ->

     
···

       315
        
       (** Concurrent POST request *)

     

       316
        
       

     

       317
        
       val put :

     

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

     

       319
        
         ?headers:Headers.t ->

     

       320
        
         ?body:Body.t ->

     

       321
        
         ?auth:Auth.t ->

     
···

       325
        
       (** Concurrent PUT request *)

     

       326
        
       

     

       327
        
       val patch :

     

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

     

       329
        
         ?headers:Headers.t ->

     

       330
        
         ?body:Body.t ->

     

       331
        
         ?auth:Auth.t ->

     
···

       335
        
       (** Concurrent PATCH request *)

     

       336
        
       

     

       337
        
       val delete :

     

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

     

       339
        
         ?headers:Headers.t ->

     

       340
        
         ?auth:Auth.t ->

     

       341
        
         ?timeout:Timeout.t ->

     
···

       344
        
       (** Concurrent DELETE request *)

     

       345
        
       

     

       346
        
       val head :

     

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

     

       348
        
         ?headers:Headers.t ->

     

       349
        
         ?auth:Auth.t ->

     

       350
        
         ?timeout:Timeout.t ->

     
···

       353
        
       (** Concurrent HEAD request *)

     

       354
        
       

     

       355
        
       val options :

     

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

     

       357
        
         ?headers:Headers.t ->

     

       358
        
         ?auth:Auth.t ->

     

       359
        
         ?timeout:Timeout.t ->

     
···

       363
        
       

     

       364
        
       (** {2 Cookie Management} *)

     

       365
        
       

     

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

     

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

     

       368
        
       

     

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

     

       370
        
       (** Clear all cookies *)

     

       371
        
       

     

       372
        
       (** {1 Cmdliner Integration} *)

     
···

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

     

       392
        
         }

     

       393
        
       

     

       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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       396
        
       

     

       397
        
         (** {2 Individual Terms} *)

     
···

       454
        
               Cmd.eval cmd

     

       455
        
             ]} *)

     

       456
        
       

     

       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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       459
        
       

     

       460
        
             This is a convenience function that combines configuration parsing

···

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

     

       133
        
       *)

     

       134
        
       

     

       135
       +
       type t

     

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

     

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

     

       138
       +
           hidden from external users. *)

     

       139
        
       

     

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

     

       141
        
       

     

       142
        
       val create :

     

       143
        
         sw:Eio.Switch.t ->

     

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

     

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

     

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

     

       147
        
         ?cookie_jar:Cookeio.jar ->

     

       148
        
         ?default_headers:Headers.t ->

     

       149
        
         ?auth:Auth.t ->

     
···

       159
        
         ?persist_cookies:bool ->

     

       160
        
         ?xdg:Xdge.t ->

     

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

     

       162
       +
         t

     

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

     

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

     

       165
        
       

     
···

       187
        
       

     

       188
        
       (** {2 Configuration Management} *)

     

       189
        
       

     

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

     

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

     

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

     

       193
        
       

     

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

     

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

     

       196
        
       

     

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

     

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

     

       199
        
       

     

       200
       +
       val clear_auth : t -> t

     

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

     

       202
        
       

     

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

     

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

     

       205
        
       

     

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

     

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

     

       208
        
       

     

       209
        
       (** {2 Request Methods}

     
···

       284
        
       *)

     

       285
        
       

     

       286
        
       val request :

     

       287
       +
         t ->

     

       288
        
         ?headers:Headers.t ->

     

       289
        
         ?body:Body.t ->

     

       290
        
         ?auth:Auth.t ->

     
···

       297
        
       (** Make a concurrent HTTP request *)

     

       298
        
       

     

       299
        
       val get :

     

       300
       +
         t ->

     

       301
        
         ?headers:Headers.t ->

     

       302
        
         ?auth:Auth.t ->

     

       303
        
         ?timeout:Timeout.t ->

     
···

       307
        
       (** Concurrent GET request *)

     

       308
        
       

     

       309
        
       val post :

     

       310
       +
         t ->

     

       311
        
         ?headers:Headers.t ->

     

       312
        
         ?body:Body.t ->

     

       313
        
         ?auth:Auth.t ->

     
···

       317
        
       (** Concurrent POST request *)

     

       318
        
       

     

       319
        
       val put :

     

       320
       +
         t ->

     

       321
        
         ?headers:Headers.t ->

     

       322
        
         ?body:Body.t ->

     

       323
        
         ?auth:Auth.t ->

     
···

       327
        
       (** Concurrent PUT request *)

     

       328
        
       

     

       329
        
       val patch :

     

       330
       +
         t ->

     

       331
        
         ?headers:Headers.t ->

     

       332
        
         ?body:Body.t ->

     

       333
        
         ?auth:Auth.t ->

     
···

       337
        
       (** Concurrent PATCH request *)

     

       338
        
       

     

       339
        
       val delete :

     

       340
       +
         t ->

     

       341
        
         ?headers:Headers.t ->

     

       342
        
         ?auth:Auth.t ->

     

       343
        
         ?timeout:Timeout.t ->

     
···

       346
        
       (** Concurrent DELETE request *)

     

       347
        
       

     

       348
        
       val head :

     

       349
       +
         t ->

     

       350
        
         ?headers:Headers.t ->

     

       351
        
         ?auth:Auth.t ->

     

       352
        
         ?timeout:Timeout.t ->

     
···

       355
        
       (** Concurrent HEAD request *)

     

       356
        
       

     

       357
        
       val options :

     

       358
       +
         t ->

     

       359
        
         ?headers:Headers.t ->

     

       360
        
         ?auth:Auth.t ->

     

       361
        
         ?timeout:Timeout.t ->

     
···

       365
        
       

     

       366
        
       (** {2 Cookie Management} *)

     

       367
        
       

     

       368
       +
       val cookies : t -> Cookeio.jar

     

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

     

       370
        
       

     

       371
       +
       val clear_cookies : t -> unit

     

       372
        
       (** Clear all cookies *)

     

       373
        
       

     

       374
        
       (** {1 Cmdliner Integration} *)

     
···

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

     

       394
        
         }

     

       395
        
       

     

       396
       +
         val create : config ->

     

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

     

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

     

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

     

       400
       +
           Eio.Switch.t -> t

     

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

     

       402
        
       

     

       403
        
         (** {2 Individual Terms} *)

     
···

       460
        
               Cmd.eval cmd

     

       461
        
             ]} *)

     

       462
        
       

     

       463
       +
         val requests_term : string ->

     

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

     

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

     

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

     

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

     

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

     

       469
        
       

     

       470
        
             This is a convenience function that combines configuration parsing

+12 -12

stack/requests_json_api/lib/requests_json_api.mli

···

       26
        
       

     

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

     

       28
        
       

     

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

     

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

     

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

     

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

     

       33
        
       

     

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

     

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

     

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

     

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

     

       38
        
       

     

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

     

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

     

       41
        
           Returns the raw response for custom handling. *)

     

       42
        
       

     

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

     

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

     

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

     

       46
        
       

     

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

     

       48
        
         (string, int * string) result

     

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

     

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

     

       51
        
       

     

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

     

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

     

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

     

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

     

       56
        
           Raises [Failure] on any error. *)

     

       57
        
       

     

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

     

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

     

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

     

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

     

       62
        
       

     

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

     

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

     

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

     

       66
        
       

     

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

     

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

     

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

     

       70
        
       

     

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

     

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

     

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

     

       74
        
       

     

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

     

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

     

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

     

       78
        
       

     
···

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

     

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

     

       93
        
       

     

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

     

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

     

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

     

       97

···

       26
        
       

     

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

     

       28
        
       

     

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

     

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

     

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

     

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

     

       33
        
       

     

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

     

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

     

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

     

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

     

       38
        
       

     

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

     

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

     

       41
        
           Returns the raw response for custom handling. *)

     

       42
        
       

     

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

     

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

     

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

     

       46
        
       

     

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

     

       48
        
         (string, int * string) result

     

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

     

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

     

       51
        
       

     

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

     

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

     

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

     

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

     

       56
        
           Raises [Failure] on any error. *)

     

       57
        
       

     

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

     

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

     

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

     

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

     

       62
        
       

     

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

     

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

     

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

     

       66
        
       

     

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

     

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

     

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

     

       70
        
       

     

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

     

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

     

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

     

       74
        
       

     

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

     

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

     

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

     

       78
        
       

     
···

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

     

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

     

       93
        
       

     

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

     

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

     

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

     

       97

+1 -2

stack/river/lib/client.ml

···

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

     

       22
        
       

     

       23
        
       type t = {

     

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

     

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

     

       26
        
       }

     

       27
        
       

     

       28
        
       let create ~sw (env : _ ) =

···

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

     

       22
        
       

     

       23
        
       type t = {

     

       24
       +
         session : Requests.t;

     

       0
        
       
     

       25
        
       }

     

       26
        
       

     

       27
        
       let create ~sw (env : _ ) =

+1 -2

stack/river/lib/client.mli

···

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

     

       55
        
       

     

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

     

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

     

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

···

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

     

       55
        
       

     

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

     

       57
       +
       val session : t -> Requests.t

     

       0

+3 -6

stack/typesense-client/typesense_client.ml

···

       6
        
         api_key : string;

     

       7
        
       }

     

       8
        
       

     

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

     

       10
       -
       type 'net t_internal = {

     

       11
        
         config: config;

     

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

     

       13
        
       }

     

       14
       -
       

     

       15
       -
       (** Public client type *)

     

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

     

       17
        
       

     

       18
        
       (** Create a new Typesense client *)

     

       19
        
       let create ~requests_session ~config : t =

···

       6
        
         api_key : string;

     

       7
        
       }

     

       8
        
       

     

       9
       +
       (** Client type *)

     

       10
       +
       type t = {

     

       11
        
         config: config;

     

       12
       +
         requests_session: Requests.t;

     

       13
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
        
       (** Create a new Typesense client *)

     

       16
        
       let create ~requests_session ~config : t =

+1 -1

stack/typesense-client/typesense_client.mli

···

       14
        
           @param config Configuration with endpoint and API key

     

       15
        
           @return A client instance *)

     

       16
        
       val create :

     

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

     

       18
        
         config:config ->

     

       19
        
         t

     

       20

···

       14
        
           @param config Configuration with endpoint and API key

     

       15
        
           @return A client instance *)

     

       16
        
       val create :

     

       17
       +
         requests_session:Requests.t ->

     

       18
        
         config:config ->

     

       19
        
         t

     

       20

+2 -2

stack/zotero-translation/zotero_translation.ml

···

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

     

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

     

       99
        
       

     

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

     

       101
        
         base_uri: string;

     

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

     

       103
        
       }

     

       104
        
       

     

       105
        
       let create ~requests_session base_uri =

···

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

     

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

     

       99
        
       

     

       100
       +
       type t = {

     

       101
        
         base_uri: string;

     

       102
       +
         requests_session: Requests.t;

     

       103
        
       }

     

       104
        
       

     

       105
        
       let create ~requests_session base_uri =

+8 -8

stack/zotero-translation/zotero_translation.mli

···

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

     

       2
        
       

     

       3
       -
       type ('clock, 'net) t

     

       4
        
       

     

       5
        
       type format =

     

       6
        
         | Bibtex

     
···

       28
        
           @param requests_session Shared Requests session for connection pooling.

     

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

     

       30
        
       val create :

     

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

     

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

     

       33
        
       

     

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

     

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

     

       36
        
       

     

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

     

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

     

       39
        
       

     

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

     

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

     

       42
        
       

     

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

     

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

     

       45
        
       

     

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

     

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

···

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

     

       2
        
       

     

       3
       +
       type t

     

       4
        
       

     

       5
        
       type format =

     

       6
        
         | Bibtex

     
···

       28
        
           @param requests_session Shared Requests session for connection pooling.

     

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

     

       30
        
       val create :

     

       31
       +
         requests_session:Requests.t ->

     

       32
       +
         string -> t

     

       33
        
       

     

       34
       +
       val resolve_doi: t ->

     

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

     

       36
        
       

     

       37
       +
       val resolve_url: t ->

     

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

     

       39
        
       

     

       40
       +
       val search_id: t ->

     

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

     

       42
        
       

     

       43
       +
       val export: t ->

     

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

     

       45
        
       

     

       46
       +
       val json_of_doi : t ->

     

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

+1 -2

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

···

       4
        
       

     

       5
        
       type t = {

     

       6
        
         auth : Auth.t;

     

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

     

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

     

       9
        
       }

     

       10
        
       

     

       11
        
       let create ~sw env auth =

···

       4
        
       

     

       5
        
       type t = {

     

       6
        
         auth : Auth.t;

     

       7
       +
         session : Requests.t;

     

       0
        
       
     

       8
        
       }

     

       9
        
       

     

       10
        
       let create ~sw env auth =