commit b7bbf5ef67b96d0a1f2e309fb46f8c76f6af69bc · anil.recoil.org/slop

stack/immiche/bin/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (name immiche_cli)

     

       3
       3
       +
        (public_name immiche)

     

       4
       4
       +
        (libraries immiche requests eio_main keyeio eiocmd cmdliner))

+187

stack/immiche/bin/immiche_cli.ml

···

       1
       1
       +
       open Cmdliner

     

       2
       2
       +
       

     

       3
       3
       +
       (** List people command *)

     

       4
       4
       +
       let list_people env _xdg profile base_url limit hidden =

     

       5
       5
       +
         Eio.Switch.run @@ fun sw ->

     

       6
       6
       +
       

     

       7
       7
       +
         let api_key = Keyeio.Profile.get_required profile ~key:"api_key" in

     

       8
       8
       +
         let base_url =

     

       9
       9
       +
           match base_url with

     

       10
       10
       +
           | Some url -> url

     

       11
       11
       +
           | None ->

     

       12
       12
       +
               Keyeio.Profile.get profile ~key:"base_url"

     

       13
       13
       +
               |> Option.value ~default:"https://photos.example.com"

     

       14
       14
       +
         in

     

       15
       15
       +
       

     

       16
       16
       +
         try

     

       17
       17
       +
           let requests_session = Requests.create ~sw env in

     

       18
       18
       +
           let client = Immiche.create ~requests_session ~base_url ~api_key in

     

       19
       19
       +
           let response = Immiche.fetch_people client in

     

       20
       20
       +
       

     

       21
       21
       +
           (* Filter by hidden status if requested *)

     

       22
       22
       +
           let people =

     

       23
       23
       +
             List.filter (fun (p : Immiche.person) ->

     

       24
       24
       +
               match hidden with

     

       25
       25
       +
               | Some true -> p.is_hidden

     

       26
       26
       +
               | Some false -> not p.is_hidden

     

       27
       27
       +
               | None -> true

     

       28
       28
       +
             ) response.people

     

       29
       29
       +
           in

     

       30
       30
       +
       

     

       31
       31
       +
           (* Limit number of results *)

     

       32
       32
       +
           let people =

     

       33
       33
       +
             match limit with

     

       34
       34
       +
             | Some n -> List.filteri (fun i _ -> i < n) people

     

       35
       35
       +
             | None -> people

     

       36
       36
       +
           in

     

       37
       37
       +
       

     

       38
       38
       +
           Printf.printf "Found %d people (total: %d, visible: %d)\n\n"

     

       39
       39
       +
             (List.length people) response.total response.visible;

     

       40
       40
       +
       

     

       41
       41
       +
           List.iteri (fun i (p : Immiche.person) ->

     

       42
       42
       +
             Printf.printf "%d. %s\n" (i + 1) p.name;

     

       43
       43
       +
             Printf.printf "   ID: %s\n" p.id;

     

       44
       44
       +
             (match p.birth_date with

     

       45
       45
       +
              | Some bd -> Printf.printf "   Birth date: %s\n" bd

     

       46
       46
       +
              | None -> ());

     

       47
       47
       +
             Printf.printf "   Thumbnail: %s\n" p.thumbnail_path;

     

       48
       48
       +
             if p.is_hidden then Printf.printf "   [HIDDEN]\n";

     

       49
       49
       +
             Printf.printf "\n"

     

       50
       50
       +
           ) people;

     

       51
       51
       +
           0

     

       52
       52
       +
         with exn ->

     

       53
       53
       +
           Printf.eprintf "Error: %s\n" (Printexc.to_string exn);

     

       54
       54
       +
           1

     

       55
       55
       +
       

     

       56
       56
       +
       (** Get a single person by ID *)

     

       57
       57
       +
       let get_person env _xdg profile base_url person_id =

     

       58
       58
       +
         Eio.Switch.run @@ fun sw ->

     

       59
       59
       +
       

     

       60
       60
       +
         let api_key = Keyeio.Profile.get_required profile ~key:"api_key" in

     

       61
       61
       +
         let base_url =

     

       62
       62
       +
           match base_url with

     

       63
       63
       +
           | Some url -> url

     

       64
       64
       +
           | None ->

     

       65
       65
       +
               Keyeio.Profile.get profile ~key:"base_url"

     

       66
       66
       +
               |> Option.value ~default:"https://photos.example.com"

     

       67
       67
       +
         in

     

       68
       68
       +
       

     

       69
       69
       +
         try

     

       70
       70
       +
           let requests_session = Requests.create ~sw env in

     

       71
       71
       +
           let client = Immiche.create ~requests_session ~base_url ~api_key in

     

       72
       72
       +
           let person = Immiche.fetch_person client ~person_id in

     

       73
       73
       +
       

     

       74
       74
       +
           Printf.printf "Person: %s\n" person.name;

     

       75
       75
       +
           Printf.printf "ID: %s\n" person.id;

     

       76
       76
       +
           (match person.birth_date with

     

       77
       77
       +
            | Some bd -> Printf.printf "Birth date: %s\n" bd

     

       78
       78
       +
            | None -> ());

     

       79
       79
       +
           Printf.printf "Thumbnail: %s\n" person.thumbnail_path;

     

       80
       80
       +
           if person.is_hidden then Printf.printf "Status: HIDDEN\n";

     

       81
       81
       +
           0

     

       82
       82
       +
         with exn ->

     

       83
       83
       +
           Printf.eprintf "Error: %s\n" (Printexc.to_string exn);

     

       84
       84
       +
           1

     

       85
       85
       +
       

     

       86
       86
       +
       (** Search for people by name *)

     

       87
       87
       +
       let search_people env _xdg profile base_url name =

     

       88
       88
       +
         Eio.Switch.run @@ fun sw ->

     

       89
       89
       +
       

     

       90
       90
       +
         let api_key = Keyeio.Profile.get_required profile ~key:"api_key" in

     

       91
       91
       +
         let base_url =

     

       92
       92
       +
           match base_url with

     

       93
       93
       +
           | Some url -> url

     

       94
       94
       +
           | None ->

     

       95
       95
       +
               Keyeio.Profile.get profile ~key:"base_url"

     

       96
       96
       +
               |> Option.value ~default:"https://photos.example.com"

     

       97
       97
       +
         in

     

       98
       98
       +
       

     

       99
       99
       +
         try

     

       100
       100
       +
           let requests_session = Requests.create ~sw env in

     

       101
       101
       +
           let client = Immiche.create ~requests_session ~base_url ~api_key in

     

       102
       102
       +
           let people = Immiche.search_person client ~name in

     

       103
       103
       +
       

     

       104
       104
       +
           Printf.printf "Found %d people matching '%s'\n\n" (List.length people) name;

     

       105
       105
       +
       

     

       106
       106
       +
           List.iteri (fun i (p : Immiche.person) ->

     

       107
       107
       +
             Printf.printf "%d. %s\n" (i + 1) p.name;

     

       108
       108
       +
             Printf.printf "   ID: %s\n" p.id;

     

       109
       109
       +
             (match p.birth_date with

     

       110
       110
       +
              | Some bd -> Printf.printf "   Birth date: %s\n" bd

     

       111
       111
       +
              | None -> ());

     

       112
       112
       +
             Printf.printf "   Thumbnail: %s\n" p.thumbnail_path;

     

       113
       113
       +
             if p.is_hidden then Printf.printf "   [HIDDEN]\n";

     

       114
       114
       +
             Printf.printf "\n"

     

       115
       115
       +
           ) people;

     

       116
       116
       +
           0

     

       117
       117
       +
         with exn ->

     

       118
       118
       +
           Printf.eprintf "Error: %s\n" (Printexc.to_string exn);

     

       119
       119
       +
           1

     

       120
       120
       +
       

     

       121
       121
       +
       (** Command-line arguments *)

     

       122
       122
       +
       

     

       123
       123
       +
       let base_url_arg =

     

       124
       124
       +
         let doc = "Base URL of the Immich instance (overrides profile setting)" in

     

       125
       125
       +
         Arg.(value & opt (some string) None & info ["u"; "url"] ~docv:"URL" ~doc)

     

       126
       126
       +
       

     

       127
       127
       +
       let limit_arg =

     

       128
       128
       +
         let doc = "Maximum number of results to return" in

     

       129
       129
       +
         Arg.(value & opt (some int) None & info ["l"; "limit"] ~docv:"N" ~doc)

     

       130
       130
       +
       

     

       131
       131
       +
       let hidden_arg =

     

       132
       132
       +
         let doc = "Filter by hidden status (true/false)" in

     

       133
       133
       +
         Arg.(value & opt (some bool) None & info ["hidden"] ~docv:"BOOL" ~doc)

     

       134
       134
       +
       

     

       135
       135
       +
       let person_id_arg =

     

       136
       136
       +
         let doc = "ID of the person" in

     

       137
       137
       +
         Arg.(required & pos 0 (some string) None & info [] ~docv:"PERSON_ID" ~doc)

     

       138
       138
       +
       

     

       139
       139
       +
       let name_arg =

     

       140
       140
       +
         let doc = "Name to search for" in

     

       141
       141
       +
         Arg.(required & pos 0 (some string) None & info [] ~docv:"NAME" ~doc)

     

       142
       142
       +
       

     

       143
       143
       +
       (** Commands *)

     

       144
       144
       +
       

     

       145
       145
       +
       let list_cmd =

     

       146
       146
       +
         let doc = "List people from Immich" in

     

       147
       147
       +
         Eiocmd.run

     

       148
       148
       +
           ~info:(Cmd.info "list" ~doc)

     

       149
       149
       +
           ~app_name:"immiche"

     

       150
       150
       +
           ~service:"immich"

     

       151
       151
       +
           Term.(const (fun base_url limit hidden env xdg profile ->

     

       152
       152
       +
             list_people env xdg profile base_url limit hidden)

     

       153
       153
       +
             $ base_url_arg $ limit_arg $ hidden_arg)

     

       154
       154
       +
       

     

       155
       155
       +
       let get_cmd =

     

       156
       156
       +
         let doc = "Get a person by ID" in

     

       157
       157
       +
         Eiocmd.run

     

       158
       158
       +
           ~info:(Cmd.info "get" ~doc)

     

       159
       159
       +
           ~app_name:"immiche"

     

       160
       160
       +
           ~service:"immich"

     

       161
       161
       +
           Term.(const (fun base_url person_id env xdg profile ->

     

       162
       162
       +
             get_person env xdg profile base_url person_id)

     

       163
       163
       +
             $ base_url_arg $ person_id_arg)

     

       164
       164
       +
       

     

       165
       165
       +
       let search_cmd =

     

       166
       166
       +
         let doc = "Search for people by name" in

     

       167
       167
       +
         Eiocmd.run

     

       168
       168
       +
           ~info:(Cmd.info "search" ~doc)

     

       169
       169
       +
           ~app_name:"immiche"

     

       170
       170
       +
           ~service:"immich"

     

       171
       171
       +
           Term.(const (fun base_url name env xdg profile ->

     

       172
       172
       +
             search_people env xdg profile base_url name)

     

       173
       173
       +
             $ base_url_arg $ name_arg)

     

       174
       174
       +
       

     

       175
       175
       +
       (** Main command *)

     

       176
       176
       +
       

     

       177
       177
       +
       let main_cmd =

     

       178
       178
       +
         let doc = "Immich API client" in

     

       179
       179
       +
         let man = [

     

       180
       180
       +
           `S Manpage.s_description;

     

       181
       181
       +
           `P "$(tname) is a command-line client for the Immich API.";

     

       182
       182
       +
           `P "It allows you to list, search, and view people from your Immich instance.";

     

       183
       183
       +
         ] in

     

       184
       184
       +
         let info = Cmd.info "immiche" ~version:"0.1.0" ~doc ~man in

     

       185
       185
       +
         Cmd.group info [list_cmd; get_cmd; search_cmd]

     

       186
       186
       +
       

     

       187
       187
       +
       let () = exit (Cmd.eval' main_cmd)

+1 -1

stack/immiche/dune

···

       1
       1
        
       (library

     

       2
       2
        
        (name immiche)

     

       3
       3
        
        (public_name immiche)

     

       4
       4
       -
        (libraries eio eio.core requests ezjsonm fmt ptime uri))

     

       4
       4
       +
        (libraries eio eio.core requests requests_json_api ezjsonm fmt ptime uri))

+22 -50

stack/immiche/immiche.ml

···

       68
       68
        
       (** {1 API Functions} *)

     

       69
       69
        
       

     

       70
       70
        
       let fetch_people { base_url; requests_session; _ } =

     

       71
       71
       -
         let url = sprintf "%s/api/people" base_url in

     

       72
       72
       -
       

     

       73
       73
       -
         let response = Requests.get requests_session url in

     

       74
       74
       -
         let status = Requests.Response.status_code response in

     

       75
       75
       -
       

     

       76
       76
       -
         if status <> 200 then

     

       77
       77
       -
           failwith (sprintf "HTTP error: %d" status)

     

       78
       78
       -
         else

     

       79
       79
       -
           let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       80
       80
       -
           let json = Ezjsonm.from_string body_str in

     

       81
       81
       -
           parse_people_response json

     

       71
       71
       +
         let open Requests_json_api in

     

       72
       72
       +
         let url = base_url / "api/people" in

     

       73
       73
       +
         get_json_exn requests_session url parse_people_response

     

       82
       74
        
       

     

       83
       75
        
       let fetch_person { base_url; requests_session; _ } ~person_id =

     

       84
       84
       -
         let url = sprintf "%s/api/people/%s" base_url person_id in

     

       85
       85
       -
       

     

       86
       86
       -
         let response = Requests.get requests_session url in

     

       87
       87
       -
         let status = Requests.Response.status_code response in

     

       88
       88
       -
       

     

       89
       89
       -
         if status <> 200 then

     

       90
       90
       -
           failwith (sprintf "HTTP error: %d" status)

     

       91
       91
       -
         else

     

       92
       92
       -
           let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       93
       93
       -
           let json = Ezjsonm.from_string body_str in

     

       94
       94
       -
           parse_person json

     

       76
       76
       +
         let open Requests_json_api in

     

       77
       77
       +
         let url = base_url / "api/people" / person_id in

     

       78
       78
       +
         get_json_exn requests_session url parse_person

     

       95
       79
        
       

     

       96
       80
        
       let download_thumbnail { base_url; requests_session; _ } ~fs ~person_id ~output_path =

     

       97
       81
        
         try

     

       98
       98
       -
           let url = sprintf "%s/api/people/%s/thumbnail" base_url person_id in

     

       99
       99
       -
       

     

       100
       100
       -
           let response = Requests.get requests_session url in

     

       101
       101
       -
           let status = Requests.Response.status_code response in

     

       102
       102
       -
       

     

       103
       103
       -
           if status <> 200 then

     

       104
       104
       -
             Error (`Msg (sprintf "HTTP error: %d" status))

     

       105
       105
       -
           else begin

     

       106
       106
       -
             let img_data = Requests.Response.body response |> Eio.Flow.read_all in

     

       82
       82
       +
           let open Requests_json_api in

     

       83
       83
       +
           let url = base_url / "api/people" / person_id / "thumbnail" in

     

       107
       84
        
       

     

       108
       108
       -
             (* Ensure output directory exists *)

     

       109
       109
       -
             let dir = Filename.dirname output_path in

     

       110
       110
       -
             if not (Sys.file_exists dir) then

     

       111
       111
       -
               Unix.mkdir dir 0o755;

     

       85
       85
       +
           match get_result requests_session url with

     

       86
       86
       +
           | Error (status, _body) ->

     

       87
       87
       +
               Error (`Msg (sprintf "HTTP error: %d" status))

     

       88
       88
       +
           | Ok img_data ->

     

       89
       89
       +
               (* Ensure output directory exists *)

     

       90
       90
       +
               let dir = Filename.dirname output_path in

     

       91
       91
       +
               if not (Sys.file_exists dir) then

     

       92
       92
       +
                 Unix.mkdir dir 0o755;

     

       112
       93
        
       

     

       113
       113
       -
             (* Write the image data to file *)

     

       114
       114
       -
             let path = Eio.Path.(fs / output_path) in

     

       115
       115
       -
             Eio.Path.save ~create:(`Or_truncate 0o644) path img_data;

     

       94
       94
       +
               (* Write the image data to file *)

     

       95
       95
       +
               let path = Eio.Path.(fs / output_path) in

     

       96
       96
       +
               Eio.Path.save ~create:(`Or_truncate 0o644) path img_data;

     

       116
       97
        
       

     

       117
       117
       -
             Ok ()

     

       118
       118
       -
           end

     

       98
       98
       +
               Ok ()

     

       119
       99
        
         with

     

       120
       100
        
         | Failure msg -> Error (`Msg msg)

     

       121
       101
        
         | exn -> Error (`Msg (Printexc.to_string exn))

     

       122
       102
        
       

     

       123
       103
        
       let search_person { base_url; requests_session; _ } ~name =

     

       104
       104
       +
         let open Requests_json_api in

     

       124
       105
        
         let encoded_name = Uri.pct_encode name in

     

       125
       106
        
         let url = sprintf "%s/api/search/person?name=%s" base_url encoded_name in

     

       126
       126
       -
       

     

       127
       127
       -
         let response = Requests.get requests_session url in

     

       128
       128
       -
         let status = Requests.Response.status_code response in

     

       129
       129
       -
       

     

       130
       130
       -
         if status <> 200 then

     

       131
       131
       -
           failwith (sprintf "HTTP error: %d" status)

     

       132
       132
       -
         else

     

       133
       133
       -
           let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       134
       134
       -
           let json = Ezjsonm.from_string body_str in

     

       135
       135
       -
           parse_person_list json

     

       107
       107
       +
         get_json_exn requests_session url parse_person_list

+1 -1

stack/karakeepe/dune

···

       1
       1
        
       (library

     

       2
       2
        
        (name karakeepe)

     

       3
       3
        
        (public_name karakeepe)

     

       4
       4
       -
        (libraries bushel eio eio.core requests ezjsonm fmt ptime uri logs logs.fmt))

     

       4
       4
       +
        (libraries bushel eio eio.core requests requests_json_api ezjsonm fmt ptime uri logs logs.fmt))

+33 -35

stack/karakeepe/karakeepe.ml

···

       274
       274
        
       

     

       275
       275
        
         try

     

       276
       276
        
           let response = Requests.get client.http_client ~headers url in

     

       277
       277
       -
           let status_code = Requests.Response.status_code response in

     

       278
       278
       -
           if status_code = 200 then begin

     

       279
       279
       -
             let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       280
       280
       -
             Log.debug (fun m -> m "Received %d bytes of response data" (String.length body_str));

     

       281
       281
       -
       

     

       282
       282
       -
             try

     

       283
       283
       -
               let json = J.from_string body_str in

     

       284
       284
       -
               parse_bookmark_response json

     

       285
       285
       -
             with e ->

     

       286
       286
       -
               Log.err (fun m -> m "JSON parsing error: %s" (Printexc.to_string e));

     

       287
       287
       -
               Log.debug (fun m -> m "Response body (first 200 chars): %s"

     

       288
       288
       -
                 (if String.length body_str > 200 then String.sub body_str 0 200 ^ "..." else body_str));

     

       289
       289
       -
               raise e

     

       290
       290
       -
           end else begin

     

       291
       291
       -
             Log.err (fun m -> m "HTTP error %d" status_code);

     

       292
       292
       -
             failwith (Fmt.str "HTTP error: %d" status_code)

     

       293
       293
       -
           end

     

       277
       277
       +
           match Requests_json_api.check_ok response with

     

       278
       278
       +
           | Ok body_str ->

     

       279
       279
       +
               Log.debug (fun m -> m "Received %d bytes of response data" (String.length body_str));

     

       280
       280
       +
               (try

     

       281
       281
       +
                 let json = J.from_string body_str in

     

       282
       282
       +
                 parse_bookmark_response json

     

       283
       283
       +
               with e ->

     

       284
       284
       +
                 Log.err (fun m -> m "JSON parsing error: %s" (Printexc.to_string e));

     

       285
       285
       +
                 Log.debug (fun m -> m "Response body (first 200 chars): %s"

     

       286
       286
       +
                   (if String.length body_str > 200 then String.sub body_str 0 200 ^ "..." else body_str));

     

       287
       287
       +
                 raise e)

     

       288
       288
       +
           | Error (status_code, _) ->

     

       289
       289
       +
               Log.err (fun m -> m "HTTP error %d" status_code);

     

       290
       290
       +
               failwith (Fmt.str "HTTP error: %d" status_code)

     

       294
       291
        
         with e ->

     

       295
       292
        
           Log.err (fun m -> m "Network error: %s" (Printexc.to_string e));

     

       296
       293
        
           raise e

     
···

       374
       371
        
       

     

       375
       372
        
       (** Fetch detailed information for a single bookmark by ID *)

     

       376
       373
        
       let fetch_bookmark_details client bookmark_id =

     

       377
       377
       -
         let url = Fmt.str "%s/api/v1/bookmarks/%s" client.base_url bookmark_id in

     

       374
       374
       +
         let open Requests_json_api in

     

       375
       375
       +
         let url = client.base_url / "api/v1/bookmarks" / bookmark_id in

     

       378
       376
        
       

     

       379
       377
        
         let headers = Requests.Headers.empty

     

       380
       378
        
           |> Requests.Headers.set "Authorization" ("Bearer " ^ client.api_key) in

     

       381
       379
        
       

     

       382
       380
        
         let response = Requests.get client.http_client ~headers url in

     

       383
       383
       -
         let status_code = Requests.Response.status_code response in

     

       384
       384
       -
         if status_code = 200 then begin

     

       385
       385
       -
           let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       386
       386
       -
           let json = J.from_string body_str in

     

       387
       387
       -
           parse_bookmark json

     

       388
       388
       -
         end else

     

       389
       389
       -
           failwith (Fmt.str "HTTP error: %d" status_code)

     

       381
       381
       +
         match check_ok response with

     

       382
       382
       +
         | Ok body_str ->

     

       383
       383
       +
             let json = J.from_string body_str in

     

       384
       384
       +
             parse_bookmark json

     

       385
       385
       +
         | Error (status_code, _) ->

     

       386
       386
       +
             failwith (Fmt.str "HTTP error: %d" status_code)

     

       390
       387
        
       

     

       391
       388
        
       (** Get the asset URL for a given asset ID *)

     

       392
       389
        
       let get_asset_url client asset_id =

     
···

       394
       391
        
       

     

       395
       392
        
       (** Fetch an asset from the Karakeep server as a binary string *)

     

       396
       393
        
       let fetch_asset client asset_id =

     

       397
       397
       -
         let url = Fmt.str "%s/api/assets/%s" client.base_url asset_id in

     

       394
       394
       +
         let open Requests_json_api in

     

       395
       395
       +
         let url = client.base_url / "api/assets" / asset_id in

     

       398
       396
        
       

     

       399
       397
        
         let headers = Requests.Headers.empty

     

       400
       398
        
           |> Requests.Headers.set "Authorization" ("Bearer " ^ client.api_key) in

     

       401
       399
        
       

     

       402
       400
        
         let response = Requests.get client.http_client ~headers url in

     

       403
       403
       -
         let status_code = Requests.Response.status_code response in

     

       404
       404
       -
         if status_code = 200 then

     

       405
       405
       -
           Requests.Response.body response |> Eio.Flow.read_all

     

       406
       406
       -
         else

     

       407
       407
       -
           failwith (Fmt.str "Asset fetch error: %d" status_code)

     

       401
       401
       +
         match check_ok response with

     

       402
       402
       +
         | Ok body_str -> body_str

     

       403
       403
       +
         | Error (status_code, _) ->

     

       404
       404
       +
             failwith (Fmt.str "Asset fetch error: %d" status_code)

     

       408
       405
        
       

     

       409
       406
        
       (** Create a new bookmark in Karakeep with optional tags *)

     

       410
       407
        
       let create_bookmark client ~url ?title ?note ?tags ?(favourited=false) ?(archived=false) () =

     
···

       433
       430
        
           |> Requests.Headers.set "Content-Type" "application/json"

     

       434
       431
        
         in

     

       435
       432
        
       

     

       436
       436
       -
         let url_endpoint = Fmt.str "%s/api/v1/bookmarks" client.base_url in

     

       433
       433
       +
         let open Requests_json_api in

     

       434
       434
       +
         let url_endpoint = client.base_url / "api/v1/bookmarks" in

     

       437
       435
        
         let body = Requests.Body.of_string Requests.Mime.json body_str in

     

       438
       436
        
         let response = Requests.post client.http_client ~headers ~body url_endpoint in

     

       439
       437
        
       

     

       440
       438
        
         let status_code = Requests.Response.status_code response in

     

       441
       439
        
         if status_code = 201 || status_code = 200 then begin

     

       442
       442
       -
           let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       440
       440
       +
           let body_str = read_body response in

     

       443
       441
        
           let json = J.from_string body_str in

     

       444
       442
        
           let bookmark = parse_bookmark json in

     

       445
       443
        
       

     
···

       452
       450
        
               let tags_body = `O [("tags", `A tag_objects)] in

     

       453
       451
        
               let tags_body_str = J.to_string tags_body in

     

       454
       452
        
       

     

       455
       455
       -
               let tags_url = Fmt.str "%s/api/v1/bookmarks/%s/tags" client.base_url bookmark.id in

     

       453
       453
       +
               let tags_url = client.base_url / "api/v1/bookmarks" / bookmark.id / "tags" in

     

       456
       454
        
               let tags_body = Requests.Body.of_string Requests.Mime.json tags_body_str in

     

       457
       455
        
               let tags_response = Requests.post client.http_client ~headers ~body:tags_body tags_url in

     

       458
       456
        
       

     
···

       463
       461
        
                 bookmark

     

       464
       462
        
           | _ -> bookmark

     

       465
       463
        
         end else begin

     

       466
       466
       -
           let error_body = Requests.Response.body response |> Eio.Flow.read_all in

     

       464
       464
       +
           let error_body = read_body response in

     

       467
       465
        
           failwith (Fmt.str "Failed to create bookmark. HTTP error: %d. Details: %s" status_code error_body)

     

       468
       466
        
         end

     

       469
       467

stack/peertubee/bin/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (name peertubee_cli)

     

       3
       3
       +
        (public_name peertubee)

     

       4
       4
       +
        (libraries peertubee requests eio_main keyeio eiocmd cmdliner))

+138

stack/peertubee/bin/peertubee_cli.ml

···

       1
       1
       +
       open Cmdliner

     

       2
       2
       +
       

     

       3
       3
       +
       (** List channel videos command *)

     

       4
       4
       +
       let list_videos env _xdg profile base_url channel limit =

     

       5
       5
       +
         Eio.Switch.run @@ fun sw ->

     

       6
       6
       +
       

     

       7
       7
       +
         let base_url =

     

       8
       8
       +
           match base_url with

     

       9
       9
       +
           | Some url -> url

     

       10
       10
       +
           | None ->

     

       11
       11
       +
               Keyeio.Profile.get profile ~key:"base_url"

     

       12
       12
       +
               |> Option.value ~default:"https://peertube.example.com"

     

       13
       13
       +
         in

     

       14
       14
       +
       

     

       15
       15
       +
         try

     

       16
       16
       +
           let requests_session = Requests.create ~sw env in

     

       17
       17
       +
           let client = Peertubee.create ~requests_session ~base_url in

     

       18
       18
       +
           let videos =

     

       19
       19
       +
             match limit with

     

       20
       20
       +
             | Some n -> Peertubee.fetch_all_channel_videos client ~page_size:n channel

     

       21
       21
       +
             | None -> Peertubee.fetch_all_channel_videos client channel

     

       22
       22
       +
           in

     

       23
       23
       +
       

     

       24
       24
       +
           Printf.printf "Found %d videos from channel '%s'\n\n" (List.length videos) channel;

     

       25
       25
       +
       

     

       26
       26
       +
           List.iteri (fun i (v : Peertubee.video) ->

     

       27
       27
       +
             Printf.printf "%d. %s\n" (i + 1) v.name;

     

       28
       28
       +
             Printf.printf "   UUID: %s\n" v.uuid;

     

       29
       29
       +
             Printf.printf "   URL: %s\n" v.url;

     

       30
       30
       +
             (match v.description with

     

       31
       31
       +
              | Some desc ->

     

       32
       32
       +
                  let desc_short =

     

       33
       33
       +
                    if String.length desc > 100 then String.sub desc 0 100 ^ "..."

     

       34
       34
       +
                    else desc

     

       35
       35
       +
                  in

     

       36
       36
       +
                  Printf.printf "   Description: %s\n" desc_short

     

       37
       37
       +
              | None -> ());

     

       38
       38
       +
             Printf.printf "   Published: %s\n" (Ptime.to_rfc3339 v.published_at);

     

       39
       39
       +
             if v.tags <> [] then

     

       40
       40
       +
               Printf.printf "   Tags: %s\n" (String.concat ", " v.tags);

     

       41
       41
       +
             Printf.printf "\n"

     

       42
       42
       +
           ) videos;

     

       43
       43
       +
           0

     

       44
       44
       +
         with exn ->

     

       45
       45
       +
           Printf.eprintf "Error: %s\n" (Printexc.to_string exn);

     

       46
       46
       +
           1

     

       47
       47
       +
       

     

       48
       48
       +
       (** Get a single video by UUID *)

     

       49
       49
       +
       let get_video env _xdg profile base_url uuid =

     

       50
       50
       +
         Eio.Switch.run @@ fun sw ->

     

       51
       51
       +
       

     

       52
       52
       +
         let base_url =

     

       53
       53
       +
           match base_url with

     

       54
       54
       +
           | Some url -> url

     

       55
       55
       +
           | None ->

     

       56
       56
       +
               Keyeio.Profile.get profile ~key:"base_url"

     

       57
       57
       +
               |> Option.value ~default:"https://peertube.example.com"

     

       58
       58
       +
         in

     

       59
       59
       +
       

     

       60
       60
       +
         try

     

       61
       61
       +
           let requests_session = Requests.create ~sw env in

     

       62
       62
       +
           let client = Peertubee.create ~requests_session ~base_url in

     

       63
       63
       +
           let video = Peertubee.fetch_video_details client uuid in

     

       64
       64
       +
       

     

       65
       65
       +
           Printf.printf "Video: %s\n" video.name;

     

       66
       66
       +
           Printf.printf "UUID: %s\n" video.uuid;

     

       67
       67
       +
           Printf.printf "URL: %s\n" video.url;

     

       68
       68
       +
           Printf.printf "Embed path: %s\n" video.embed_path;

     

       69
       69
       +
           (match video.description with

     

       70
       70
       +
            | Some desc -> Printf.printf "Description: %s\n" desc

     

       71
       71
       +
            | None -> ());

     

       72
       72
       +
           Printf.printf "Published: %s\n" (Ptime.to_rfc3339 video.published_at);

     

       73
       73
       +
           (match video.originally_published_at with

     

       74
       74
       +
            | Some t -> Printf.printf "Originally published: %s\n" (Ptime.to_rfc3339 t)

     

       75
       75
       +
            | None -> ());

     

       76
       76
       +
           if video.tags <> [] then

     

       77
       77
       +
             Printf.printf "Tags: %s\n" (String.concat ", " video.tags);

     

       78
       78
       +
           (match Peertubee.thumbnail_url client video with

     

       79
       79
       +
            | Some url -> Printf.printf "Thumbnail: %s\n" url

     

       80
       80
       +
            | None -> ());

     

       81
       81
       +
           0

     

       82
       82
       +
         with exn ->

     

       83
       83
       +
           Printf.eprintf "Error: %s\n" (Printexc.to_string exn);

     

       84
       84
       +
           1

     

       85
       85
       +
       

     

       86
       86
       +
       (** Command-line arguments *)

     

       87
       87
       +
       

     

       88
       88
       +
       let base_url_arg =

     

       89
       89
       +
         let doc = "Base URL of the PeerTube instance (overrides profile setting)" in

     

       90
       90
       +
         Arg.(value & opt (some string) None & info ["u"; "url"] ~docv:"URL" ~doc)

     

       91
       91
       +
       

     

       92
       92
       +
       let channel_arg =

     

       93
       93
       +
         let doc = "Channel name to fetch videos from" in

     

       94
       94
       +
         Arg.(required & pos 0 (some string) None & info [] ~docv:"CHANNEL" ~doc)

     

       95
       95
       +
       

     

       96
       96
       +
       let limit_arg =

     

       97
       97
       +
         let doc = "Maximum number of videos to return" in

     

       98
       98
       +
         Arg.(value & opt (some int) None & info ["l"; "limit"] ~docv:"N" ~doc)

     

       99
       99
       +
       

     

       100
       100
       +
       let uuid_arg =

     

       101
       101
       +
         let doc = "UUID of the video" in

     

       102
       102
       +
         Arg.(required & pos 0 (some string) None & info [] ~docv:"UUID" ~doc)

     

       103
       103
       +
       

     

       104
       104
       +
       (** Commands *)

     

       105
       105
       +
       

     

       106
       106
       +
       let list_cmd =

     

       107
       107
       +
         let doc = "List videos from a PeerTube channel" in

     

       108
       108
       +
         Eiocmd.run

     

       109
       109
       +
           ~info:(Cmd.info "list" ~doc)

     

       110
       110
       +
           ~app_name:"peertubee"

     

       111
       111
       +
           ~service:"peertube"

     

       112
       112
       +
           Term.(const (fun base_url channel limit env xdg profile ->

     

       113
       113
       +
             list_videos env xdg profile base_url channel limit)

     

       114
       114
       +
             $ base_url_arg $ channel_arg $ limit_arg)

     

       115
       115
       +
       

     

       116
       116
       +
       let get_cmd =

     

       117
       117
       +
         let doc = "Get a video by UUID" in

     

       118
       118
       +
         Eiocmd.run

     

       119
       119
       +
           ~info:(Cmd.info "get" ~doc)

     

       120
       120
       +
           ~app_name:"peertubee"

     

       121
       121
       +
           ~service:"peertube"

     

       122
       122
       +
           Term.(const (fun base_url uuid env xdg profile ->

     

       123
       123
       +
             get_video env xdg profile base_url uuid)

     

       124
       124
       +
             $ base_url_arg $ uuid_arg)

     

       125
       125
       +
       

     

       126
       126
       +
       (** Main command *)

     

       127
       127
       +
       

     

       128
       128
       +
       let main_cmd =

     

       129
       129
       +
         let doc = "PeerTube API client" in

     

       130
       130
       +
         let man = [

     

       131
       131
       +
           `S Manpage.s_description;

     

       132
       132
       +
           `P "$(tname) is a command-line client for the PeerTube API.";

     

       133
       133
       +
           `P "It allows you to list and view videos from PeerTube instances.";

     

       134
       134
       +
         ] in

     

       135
       135
       +
         let info = Cmd.info "peertubee" ~version:"0.1.0" ~doc ~man in

     

       136
       136
       +
         Cmd.group info [list_cmd; get_cmd]

     

       137
       137
       +
       

     

       138
       138
       +
       let () = exit (Cmd.eval' main_cmd)

+1 -1

stack/peertubee/dune

···

       1
       1
        
       (library

     

       2
       2
        
        (name peertubee)

     

       3
       3
        
        (public_name peertubee)

     

       4
       4
       -
        (libraries ezjsonm eio eio.core requests ptime fmt))

     

       4
       4
       +
        (libraries ezjsonm eio eio.core requests requests_json_api ptime fmt))

+17 -31

stack/peertubee/peertubee.ml

···

       102
       102
        
           @param channel Channel name to fetch videos from

     

       103
       103
        
           @return The video response *)

     

       104
       104
        
       let fetch_channel_videos client ?(count=20) ?(start=0) channel =

     

       105
       105
       +
         let open Requests_json_api in

     

       105
       106
        
         let url = Printf.sprintf "%s/api/v1/video-channels/%s/videos?count=%d&start=%d"

     

       106
       107
        
                     client.base_url channel count start in

     

       107
       107
       -
         let response = Requests.get client.requests_session url in

     

       108
       108
       -
         let status_code = Requests.Response.status_code response in

     

       109
       109
       -
         if status_code = 200 then

     

       110
       110
       -
           let s = Requests.Response.body response |> Eio.Flow.read_all in

     

       111
       111
       -
           let json = J.from_string s in

     

       112
       112
       -
           parse_video_response json

     

       113
       113
       -
         else

     

       114
       114
       -
           failwith (Fmt.str "HTTP error: %d" status_code)

     

       108
       108
       +
         get_json_exn client.requests_session url parse_video_response

     

       115
       109
        
       

     

       116
       110
        
       (** Fetch all videos from a PeerTube instance channel using pagination

     

       117
       111
        
           @param page_size Number of videos to fetch per page

     
···

       144
       138
        
           @param uuid UUID of the video to fetch

     

       145
       139
        
           @return The complete video details *)

     

       146
       140
        
       let fetch_video_details client uuid =

     

       147
       147
       -
         let url = Printf.sprintf "%s/api/v1/videos/%s" client.base_url uuid in

     

       148
       148
       -
         let response = Requests.get client.requests_session url in

     

       149
       149
       -
         let status_code = Requests.Response.status_code response in

     

       150
       150
       -
         if status_code = 200 then

     

       151
       151
       -
           let s = Requests.Response.body response |> Eio.Flow.read_all in

     

       152
       152
       -
           let json = J.from_string s in

     

       153
       153
       -
           (* Parse the single video details *)

     

       154
       154
       -
           parse_video json

     

       155
       155
       -
         else

     

       156
       156
       -
           failwith (Fmt.str "HTTP error: %d" status_code)

     

       141
       141
       +
         let open Requests_json_api in

     

       142
       142
       +
         let url = client.base_url / "api/v1/videos" / uuid in

     

       143
       143
       +
         get_json_exn client.requests_session url parse_video

     

       157
       144
        
       

     

       158
       145
        
       (** Convert a PeerTube video to Bushel.Video.t compatible structure *)

     

       159
       146
        
       let to_bushel_video video =

     
···

       179
       166
        
             Error (`Msg (Printf.sprintf "No thumbnail available for video %s" video.uuid))

     

       180
       167
        
         | Some url ->

     

       181
       168
        
             try

     

       182
       182
       -
               let response = Requests.get client.requests_session url in

     

       183
       183
       -
               let status_code = Requests.Response.status_code response in

     

       184
       184
       -
               if status_code = 200 then

     

       185
       185
       -
                 let body_str = Requests.Response.body response |> Eio.Flow.read_all in

     

       186
       186
       -
                 try

     

       187
       187
       -
                   let output_eio_path = Eio.Path.(fs / output_path) in

     

       188
       188
       -
                   Eio.Path.save ~create:(`Or_truncate 0o644) output_eio_path body_str;

     

       189
       189
       -
                   Ok ()

     

       190
       190
       -
                 with exn ->

     

       191
       191
       -
                   Error (`Msg (Printf.sprintf "Failed to write thumbnail: %s"

     

       192
       192
       -
                     (Printexc.to_string exn)))

     

       193
       193
       -
               else

     

       194
       194
       -
                 Error (`Msg (Printf.sprintf "HTTP error downloading thumbnail: %d" status_code))

     

       169
       169
       +
               let open Requests_json_api in

     

       170
       170
       +
               match get_result client.requests_session url with

     

       171
       171
       +
               | Error (status_code, _body) ->

     

       172
       172
       +
                   Error (`Msg (Printf.sprintf "HTTP error downloading thumbnail: %d" status_code))

     

       173
       173
       +
               | Ok body_str ->

     

       174
       174
       +
                   try

     

       175
       175
       +
                     let output_eio_path = Eio.Path.(fs / output_path) in

     

       176
       176
       +
                     Eio.Path.save ~create:(`Or_truncate 0o644) output_eio_path body_str;

     

       177
       177
       +
                     Ok ()

     

       178
       178
       +
                   with exn ->

     

       179
       179
       +
                     Error (`Msg (Printf.sprintf "Failed to write thumbnail: %s"

     

       180
       180
       +
                       (Printexc.to_string exn)))

     

       195
       181
        
             with exn ->

     

       196
       182
        
               Error (`Msg (Printf.sprintf "Failed to download thumbnail: %s"

     

       197
       183
        
                 (Printexc.to_string exn)))

stack/requests/lib/dune

+20

stack/requests_json_api/dune-project

···

       1
       1
       +
       (lang dune 3.0)

     

       2
       2
       +
       (name requests_json_api)

     

       3
       3
       +
       

     

       4
       4
       +
       (generate_opam_files true)

     

       5
       5
       +
       

     

       6
       6
       +
       (source (github yourusername/requests_json_api))

     

       7
       7
       +
       (license MIT)

     

       8
       8
       +
       (authors "Your Name")

     

       9
       9
       +
       (maintainers "Your Name")

     

       10
       10
       +
       

     

       11
       11
       +
       (package

     

       12
       12
       +
        (name requests_json_api)

     

       13
       13
       +
        (synopsis "JSON API helpers for the Requests HTTP client library")

     

       14
       14
       +
        (description "Convenient combinators for working with JSON APIs using the Requests library")

     

       15
       15
       +
        (depends

     

       16
       16
       +
         (ocaml (>= 5.0))

     

       17
       17
       +
         dune

     

       18
       18
       +
         requests

     

       19
       19
       +
         eio

     

       20
       20
       +
         ezjsonm))

stack/requests_json_api/lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (public_name requests_json_api)

     

       3
       3
       +
        (name requests_json_api)

     

       4
       4
       +
        (libraries requests eio ezjsonm))

+121

stack/requests_json_api/lib/requests_json_api.ml

···

       1
       1
       +
       (** JSON API Helpers for Requests *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Response Helpers} *)

     

       4
       4
       +
       

     

       5
       5
       +
       let read_body response = Requests.Response.body response |> Eio.Flow.read_all

     

       6
       6
       +
       

     

       7
       7
       +
       let status response = Requests.Response.status_code response

     

       8
       8
       +
       

     

       9
       9
       +
       let is_ok response = status response = 200

     

       10
       10
       +
       

     

       11
       11
       +
       let is_2xx response =

     

       12
       12
       +
         let s = status response in

     

       13
       13
       +
         s >= 200 && s < 300

     

       14
       14
       +
       

     

       15
       15
       +
       let check_2xx response =

     

       16
       16
       +
         let status = status response in

     

       17
       17
       +
         let body = read_body response in

     

       18
       18
       +
         if status >= 200 && status < 300 then Ok body

     

       19
       19
       +
         else Error (status, body)

     

       20
       20
       +
       

     

       21
       21
       +
       let check_ok response =

     

       22
       22
       +
         let status = status response in

     

       23
       23
       +
         let body = read_body response in

     

       24
       24
       +
         if status = 200 then Ok body

     

       25
       25
       +
         else Error (status, body)

     

       26
       26
       +
       

     

       27
       27
       +
       (** {1 Request Helpers with Status Checking} *)

     

       28
       28
       +
       

     

       29
       29
       +
       let get_ok session url =

     

       30
       30
       +
         let response = Requests.get session url in

     

       31
       31
       +
         if not (is_ok response) then

     

       32
       32
       +
           failwith (Printf.sprintf "HTTP %d" (status response));

     

       33
       33
       +
         read_body response

     

       34
       34
       +
       

     

       35
       35
       +
       let get_2xx session url =

     

       36
       36
       +
         let response = Requests.get session url in

     

       37
       37
       +
         if not (is_2xx response) then

     

       38
       38
       +
           failwith (Printf.sprintf "HTTP %d" (status response));

     

       39
       39
       +
         read_body response

     

       40
       40
       +
       

     

       41
       41
       +
       let get_result session url =

     

       42
       42
       +
         try

     

       43
       43
       +
           let response = Requests.get session url in

     

       44
       44
       +
           check_2xx response

     

       45
       45
       +
         with exn ->

     

       46
       46
       +
           Error (0, Printexc.to_string exn)

     

       47
       47
       +
       

     

       48
       48
       +
       (** {1 JSON Helpers} *)

     

       49
       49
       +
       

     

       50
       50
       +
       let parse_json parser body_str =

     

       51
       51
       +
         Ezjsonm.from_string body_str |> parser

     

       52
       52
       +
       

     

       53
       53
       +
       let parse_json_result parser body_str =

     

       54
       54
       +
         try Ok (parse_json parser body_str)

     

       55
       55
       +
         with exn -> Error (Printexc.to_string exn)

     

       56
       56
       +
       

     

       57
       57
       +
       let get_json_exn session url parser =

     

       58
       58
       +
         get_2xx session url |> parse_json parser

     

       59
       59
       +
       

     

       60
       60
       +
       let get_json session url parser =

     

       61
       61
       +
         match get_result session url with

     

       62
       62
       +
         | Ok body ->

     

       63
       63
       +
             (match parse_json_result parser body with

     

       64
       64
       +
              | Ok result -> Ok result

     

       65
       65
       +
              | Error msg -> Error (`Json_error msg))

     

       66
       66
       +
         | Error (status, body) -> Error (`Http (status, body))

     

       67
       67
       +
       

     

       68
       68
       +
       let post_json session url json_value =

     

       69
       69
       +
         let body_str = Ezjsonm.value_to_string json_value in

     

       70
       70
       +
         let body = Requests.Body.of_string Requests.Mime.json body_str in

     

       71
       71
       +
         Requests.post session url ~body

     

       72
       72
       +
       

     

       73
       73
       +
       let post_json_exn session url json_value =

     

       74
       74
       +
         let response = post_json session url json_value in

     

       75
       75
       +
         if not (is_2xx response) then

     

       76
       76
       +
           failwith (Printf.sprintf "HTTP %d" (status response));

     

       77
       77
       +
         read_body response

     

       78
       78
       +
       

     

       79
       79
       +
       let post_json_result session url json_value =

     

       80
       80
       +
         try

     

       81
       81
       +
           let response = post_json session url json_value in

     

       82
       82
       +
           check_2xx response

     

       83
       83
       +
         with exn ->

     

       84
       84
       +
           Error (0, Printexc.to_string exn)

     

       85
       85
       +
       

     

       86
       86
       +
       (** {1 URL Helpers} *)

     

       87
       87
       +
       

     

       88
       88
       +
       let ( / ) base path =

     

       89
       89
       +
         (* Handle trailing slash in base and leading slash in path *)

     

       90
       90
       +
         let base = if String.ends_with ~suffix:"/" base then String.sub base 0 (String.length base - 1) else base in

     

       91
       91
       +
         let path = if String.starts_with ~prefix:"/" path then String.sub path 1 (String.length path - 1) else path in

     

       92
       92
       +
         base ^ "/" ^ path

     

       93
       93
       +
       

     

       94
       94
       +
       let make_url = ( / )

     

       95
       95
       +
       

     

       96
       96
       +
       (** {1 Let Syntax for Composition} *)

     

       97
       97
       +
       

     

       98
       98
       +
       module Syntax = struct

     

       99
       99
       +
         let ( let* ) x f = Result.bind x f

     

       100
       100
       +
         let ( let+ ) x f = Result.map f x

     

       101
       101
       +
         let ( and* ) a b = match a, b with

     

       102
       102
       +
           | Ok a, Ok b -> Ok (a, b)

     

       103
       103
       +
           | Error e, _ | _, Error e -> Error e

     

       104
       104
       +
         let ( and+ ) = ( and* )

     

       105
       105
       +
       end

     

       106
       106
       +
       

     

       107
       107
       +
       (** {1 Convenience Combinators} *)

     

       108
       108
       +
       

     

       109
       109
       +
       let or_fail = function

     

       110
       110
       +
         | Ok x -> x

     

       111
       111
       +
         | Error (`Http (code, msg)) ->

     

       112
       112
       +
             failwith (Printf.sprintf "HTTP %d: %s" code msg)

     

       113
       113
       +
         | Error (`Json_error msg) ->

     

       114
       114
       +
             failwith (Printf.sprintf "JSON error: %s" msg)

     

       115
       115
       +
       

     

       116
       116
       +
       let or_fail_with prefix = function

     

       117
       117
       +
         | Ok x -> x

     

       118
       118
       +
         | Error (`Http (code, msg)) ->

     

       119
       119
       +
             failwith (Printf.sprintf "%s: HTTP %d: %s" prefix code msg)

     

       120
       120
       +
         | Error (`Json_error msg) ->

     

       121
       121
       +
             failwith (Printf.sprintf "%s: JSON error: %s" prefix msg)

+115

stack/requests_json_api/lib/requests_json_api.mli

···

       1
       1
       +
       (** JSON API Helpers for Requests

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides convenient combinators for working with JSON APIs,

     

       4
       4
       +
           reducing boilerplate code for common patterns like:

     

       5
       5
       +
           - Making requests and checking status codes

     

       6
       6
       +
           - Reading response bodies as strings

     

       7
       7
       +
           - Parsing JSON responses

     

       8
       8
       +
           - Building URLs from base + path

     

       9
       9
       +
           - Creating JSON request bodies

     

       10
       10
       +
       

     

       11
       11
       +
           {2 Example Usage}

     

       12
       12
       +
       

     

       13
       13
       +
           {[

     

       14
       14
       +
             open Requests_json_api

     

       15
       15
       +
       

     

       16
       16
       +
             let fetch_users session =

     

       17
       17
       +
               get_json_exn session (base_url / "users") parse_users

     

       18
       18
       +
           ]}

     

       19
       19
       +
       *)

     

       20
       20
       +
       

     

       21
       21
       +
       (** {1 Response Helpers} *)

     

       22
       22
       +
       

     

       23
       23
       +
       val read_body : Requests.Response.t -> string

     

       24
       24
       +
       (** Read response body as a string. Equivalent to:

     

       25
       25
       +
           [Requests.Response.body response |> Eio.Flow.read_all] *)

     

       26
       26
       +
       

     

       27
       27
       +
       val status : Requests.Response.t -> int

     

       28
       28
       +
       (** Get status code. Alias for [Requests.Response.status_code] *)

     

       29
       29
       +
       

     

       30
       30
       +
       val is_ok : Requests.Response.t -> bool

     

       31
       31
       +
       (** Check if status is exactly 200 *)

     

       32
       32
       +
       

     

       33
       33
       +
       val is_2xx : Requests.Response.t -> bool

     

       34
       34
       +
       (** Check if status is in 200-299 range *)

     

       35
       35
       +
       

     

       36
       36
       +
       val check_2xx : Requests.Response.t -> (string, int * string) result

     

       37
       37
       +
       (** Check if response is 2xx and return body, or error with (status, body) *)

     

       38
       38
       +
       

     

       39
       39
       +
       val check_ok : Requests.Response.t -> (string, int * string) result

     

       40
       40
       +
       (** Check if response is 200 and return body, or error with (status, body) *)

     

       41
       41
       +
       

     

       42
       42
       +
       (** {1 Request Helpers with Status Checking} *)

     

       43
       43
       +
       

     

       44
       44
       +
       val get_ok : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> string

     

       45
       45
       +
       (** [get_ok session url] makes a GET request and returns the body as string.

     

       46
       46
       +
           Raises [Failure] if status is not 200. *)

     

       47
       47
       +
       

     

       48
       48
       +
       val get_2xx : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> string

     

       49
       49
       +
       (** Like [get_ok] but accepts any 2xx status code.

     

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

     

       51
       51
       +
       

     

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

     

       53
       53
       +
       (** [get_result session url] makes a GET request and returns Result.

     

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

     

       55
       55
       +
       

     

       56
       56
       +
       (** {1 JSON Helpers} *)

     

       57
       57
       +
       

     

       58
       58
       +
       val parse_json : (Ezjsonm.value -> 'a) -> string -> 'a

     

       59
       59
       +
       (** [parse_json parser body_str] parses JSON string and applies parser.

     

       60
       60
       +
           Raises exception on parse error. *)

     

       61
       61
       +
       

     

       62
       62
       +
       val parse_json_result : (Ezjsonm.value -> 'a) -> string -> ('a, string) result

     

       63
       63
       +
       (** Like [parse_json] but returns Result on parse error. *)

     

       64
       64
       +
       

     

       65
       65
       +
       val get_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> (Ezjsonm.value -> 'a) -> 'a

     

       66
       66
       +
       (** [get_json_exn session url parser] does GET request, checks status is 2xx,

     

       67
       67
       +
           reads body, parses JSON, and applies parser. Raises on any error. *)

     

       68
       68
       +
       

     

       69
       69
       +
       val get_json : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> (Ezjsonm.value -> 'a) ->

     

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

     

       71
       71
       +
       (** Like [get_json_exn] but returns Result instead of raising. *)

     

       72
       72
       +
       

     

       73
       73
       +
       val post_json : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> Ezjsonm.value -> Requests.Response.t

     

       74
       74
       +
       (** [post_json session url json_value] creates JSON body and POSTs it. *)

     

       75
       75
       +
       

     

       76
       76
       +
       val post_json_exn : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> Ezjsonm.value -> string

     

       77
       77
       +
       (** Like [post_json] but checks status is 2xx and returns body. Raises on error. *)

     

       78
       78
       +
       

     

       79
       79
       +
       val post_json_result : (_ Eio.Time.clock, _ Eio.Net.t) Requests.t -> string -> Ezjsonm.value ->

     

       80
       80
       +
         (string, int * string) result

     

       81
       81
       +
       (** Like [post_json_exn] but returns Result. *)

     

       82
       82
       +
       

     

       83
       83
       +
       (** {1 URL Helpers} *)

     

       84
       84
       +
       

     

       85
       85
       +
       val ( / ) : string -> string -> string

     

       86
       86
       +
       (** [base_url / path] joins base URL and path, handling trailing/leading slashes.

     

       87
       87
       +
           Example: ["https://api.com" / "users" / "123"] *)

     

       88
       88
       +
       

     

       89
       89
       +
       val make_url : string -> string -> string

     

       90
       90
       +
       (** [make_url base_url path] is the function form of [/]. *)

     

       91
       91
       +
       

     

       92
       92
       +
       (** {1 Let Syntax for Composition} *)

     

       93
       93
       +
       

     

       94
       94
       +
       module Syntax : sig

     

       95
       95
       +
         val ( let* ) : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result

     

       96
       96
       +
         (** Result bind operator for chaining operations *)

     

       97
       97
       +
       

     

       98
       98
       +
         val ( let+ ) : ('a, 'e) result -> ('a -> 'b) -> ('b, 'e) result

     

       99
       99
       +
         (** Result map operator *)

     

       100
       100
       +
       

     

       101
       101
       +
         val ( and* ) : ('a, 'e) result -> ('b, 'e) result -> ('a * 'b, 'e) result

     

       102
       102
       +
         (** Result product for parallel operations *)

     

       103
       103
       +
       

     

       104
       104
       +
         val ( and+ ) : ('a, 'e) result -> ('b, 'e) result -> ('a * 'b, 'e) result

     

       105
       105
       +
         (** Result product for parallel operations (alias) *)

     

       106
       106
       +
       end

     

       107
       107
       +
       

     

       108
       108
       +
       (** {1 Convenience Combinators} *)

     

       109
       109
       +
       

     

       110
       110
       +
       val or_fail : ('a, [< `Http of int * string | `Json_error of string]) result -> 'a

     

       111
       111
       +
       (** [or_fail result] unwraps a result or raises [Failure] with error message.

     

       112
       112
       +
           Useful for converting Result-based APIs to exception-based. *)

     

       113
       113
       +
       

     

       114
       114
       +
       val or_fail_with : string -> ('a, [< `Http of int * string | `Json_error of string]) result -> 'a

     

       115
       115
       +
       (** Like [or_fail] but with custom error prefix. *)

+33

stack/requests_json_api/requests_json_api.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "JSON API helpers for the Requests HTTP client library"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "Convenient combinators for working with JSON APIs using the Requests library"

     

       6
       6
       +
       maintainer: ["Your Name"]

     

       7
       7
       +
       authors: ["Your Name"]

     

       8
       8
       +
       license: "MIT"

     

       9
       9
       +
       homepage: "https://github.com/yourusername/requests_json_api"

     

       10
       10
       +
       bug-reports: "https://github.com/yourusername/requests_json_api/issues"

     

       11
       11
       +
       depends: [

     

       12
       12
       +
         "ocaml" {>= "5.0"}

     

       13
       13
       +
         "dune" {>= "3.0"}

     

       14
       14
       +
         "requests"

     

       15
       15
       +
         "eio"

     

       16
       16
       +
         "ezjsonm"

     

       17
       17
       +
         "odoc" {with-doc}

     

       18
       18
       +
       ]

     

       19
       19
       +
       build: [

     

       20
       20
       +
         ["dune" "subst"] {dev}

     

       21
       21
       +
         [

     

       22
       22
       +
           "dune"

     

       23
       23
       +
           "build"

     

       24
       24
       +
           "-p"

     

       25
       25
       +
           name

     

       26
       26
       +
           "-j"

     

       27
       27
       +
           jobs

     

       28
       28
       +
           "@install"

     

       29
       29
       +
           "@runtest" {with-test}

     

       30
       30
       +
           "@doc" {with-doc}

     

       31
       31
       +
         ]

     

       32
       32
       +
       ]

     

       33
       33
       +
       dev-repo: "git+https://github.com/yourusername/requests_json_api.git"

+1 -1

stack/typesense-cliente/dune

···

       1
       1
        
       (library

     

       2
       2
        
        (public_name typesense-cliente)

     

       3
       3
        
        (name typesense_cliente)

     

       4
       4
       -
        (libraries eio requests ezjsonm fmt uri ptime))

     

       4
       4
       +
        (libraries eio requests requests_json_api ezjsonm fmt uri ptime))

+20 -30

stack/typesense-cliente/typesense_cliente.ml

···

       35
       35
        
       

     

       36
       36
        
       (** Make HTTP request to Typesense API *)

     

       37
       37
        
       let make_request client ?(meth=`GET) ?(body="") path =

     

       38
       38
       +
         let open Requests_json_api in

     

       38
       39
        
         let uri = Uri.of_string (client.config.endpoint ^ path) in

     

       39
       40
        
         let body = if body = "" then None else Some (Requests.Body.of_string Requests.Mime.json body) in

     

       40
       41
        
       

     
···

       45
       46
        
             (Uri.to_string uri)

     

       46
       47
        
           in

     

       47
       48
        
       

     

       48
       48
       -
           let status = Requests.Response.status_code response in

     

       49
       49
       -
           let body_flow = Requests.Response.body response in

     

       50
       50
       -
           let body_str = Eio.Flow.read_all body_flow in

     

       51
       51
       -
       

     

       52
       52
       -
           if status >= 200 && status < 300 then

     

       53
       53
       -
             Ok body_str

     

       54
       54
       -
           else

     

       55
       55
       -
             Error (Http_error (status, body_str))

     

       49
       49
       +
           match check_2xx response with

     

       50
       50
       +
           | Ok body_str -> Ok body_str

     

       51
       51
       +
           | Error (status, body_str) -> Error (Http_error (status, body_str))

     

       56
       52
        
         with exn ->

     

       57
       53
        
           Error (Connection_error (Printexc.to_string exn))

     

       58
       54
        
       

     
···

       132
       128
        
       

     

       133
       129
        
         match make_request client path with

     

       134
       130
        
         | Ok response_str ->

     

       135
       135
       -
           (try

     

       136
       136
       -
             let json = Ezjsonm.from_string response_str in

     

       137
       137
       -
             let search_response = parse_search_response collection_name json in

     

       138
       138
       -
             Ok search_response

     

       139
       139
       -
           with exn ->

     

       140
       140
       -
             Error (Json_error (Printexc.to_string exn)))

     

       131
       131
       +
             (match Requests_json_api.parse_json_result (parse_search_response collection_name) response_str with

     

       132
       132
       +
              | Ok search_response -> Ok search_response

     

       133
       133
       +
              | Error msg -> Error (Json_error msg))

     

       141
       134
        
         | Error err -> Error err

     

       142
       135
        
       

     

       143
       136
        
       (** Helper function to drop n elements from list *)

     
···

       206
       199
        
       

     

       207
       200
        
         match make_request client ~meth:`POST ~body "/multi_search" with

     

       208
       201
        
         | Ok response_str ->

     

       209
       209
       -
           (try

     

       210
       210
       -
             let json = Ezjsonm.from_string response_str in

     

       211
       211
       -
             let multisearch_resp = parse_multisearch_response json in

     

       212
       212
       -
             Ok multisearch_resp

     

       213
       213
       -
           with exn ->

     

       214
       214
       -
             Error (Json_error (Printexc.to_string exn)))

     

       202
       202
       +
             (match Requests_json_api.parse_json_result parse_multisearch_response response_str with

     

       203
       203
       +
              | Ok multisearch_resp -> Ok multisearch_resp

     

       204
       204
       +
              | Error msg -> Error (Json_error msg))

     

       215
       205
        
         | Error err -> Error err

     

       216
       206
        
       

     

       217
       207
        
       (** Combine multisearch results into single result set *)

     
···

       236
       226
        
       

     

       237
       227
        
       (** List all collections *)

     

       238
       228
        
       let list_collections client =

     

       229
       229
       +
         let parse_collections json =

     

       230
       230
       +
           Ezjsonm.get_list (fun c ->

     

       231
       231
       +
             let name = Ezjsonm.get_dict c |> List.assoc "name" |> Ezjsonm.get_string in

     

       232
       232
       +
             let num_docs = Ezjsonm.get_dict c |> List.assoc "num_documents" |> Ezjsonm.get_int in

     

       233
       233
       +
             (name, num_docs)

     

       234
       234
       +
           ) json

     

       235
       235
       +
         in

     

       239
       236
        
         match make_request client "/collections" with

     

       240
       237
        
         | Ok response_str ->

     

       241
       241
       -
           (try

     

       242
       242
       -
             let json = Ezjsonm.from_string response_str in

     

       243
       243
       -
             let collections = Ezjsonm.get_list (fun c ->

     

       244
       244
       -
               let name = Ezjsonm.get_dict c |> List.assoc "name" |> Ezjsonm.get_string in

     

       245
       245
       -
               let num_docs = Ezjsonm.get_dict c |> List.assoc "num_documents" |> Ezjsonm.get_int in

     

       246
       246
       -
               (name, num_docs)

     

       247
       247
       -
             ) json in

     

       248
       248
       -
             Ok collections

     

       249
       249
       -
           with exn ->

     

       250
       250
       -
             Error (Json_error (Printexc.to_string exn)))

     

       238
       238
       +
             (match Requests_json_api.parse_json_result parse_collections response_str with

     

       239
       239
       +
              | Ok collections -> Ok collections

     

       240
       240
       +
              | Error msg -> Error (Json_error msg))

     

       251
       241
        
         | Error err -> Error err

     

       252
       242
        
       

     

       253
       243
        
       (** Pretty printer utilities *)