commit a5e7bfeee3ac3240862be63f04869b3d88a159a1 · anil.recoil.org/slop

+88 -12

stack/sortal/lib/sortal.ml

···

       1
       1
       +
       module Feed = struct

     

       2
       2
       +
         type feed_type =

     

       3
       3
       +
           | Atom

     

       4
       4
       +
           | Rss

     

       5
       5
       +
           | Json

     

       6
       6
       +
       

     

       7
       7
       +
         type t = {

     

       8
       8
       +
           feed_type : feed_type;

     

       9
       9
       +
           url : string;

     

       10
       10
       +
           name : string option;

     

       11
       11
       +
         }

     

       12
       12
       +
       

     

       13
       13
       +
         let make ~feed_type ~url ?name () =

     

       14
       14
       +
           { feed_type; url; name }

     

       15
       15
       +
       

     

       16
       16
       +
         let feed_type t = t.feed_type

     

       17
       17
       +
         let url t = t.url

     

       18
       18
       +
         let name t = t.name

     

       19
       19
       +
       

     

       20
       20
       +
         let set_name t name = { t with name = Some name }

     

       21
       21
       +
       

     

       22
       22
       +
         let feed_type_to_string = function

     

       23
       23
       +
           | Atom -> "atom"

     

       24
       24
       +
           | Rss -> "rss"

     

       25
       25
       +
           | Json -> "json"

     

       26
       26
       +
       

     

       27
       27
       +
         let feed_type_of_string = function

     

       28
       28
       +
           | "atom" -> Some Atom

     

       29
       29
       +
           | "rss" -> Some Rss

     

       30
       30
       +
           | "json" -> Some Json

     

       31
       31
       +
           | _ -> None

     

       32
       32
       +
       

     

       33
       33
       +
         let json_t =

     

       34
       34
       +
           let open Jsont in

     

       35
       35
       +
           let open Jsont.Object in

     

       36
       36
       +
           let make feed_type url name =

     

       37
       37
       +
             match feed_type_of_string feed_type with

     

       38
       38
       +
             | Some ft -> { feed_type = ft; url; name }

     

       39
       39
       +
             | None -> failwith ("Invalid feed type: " ^ feed_type)

     

       40
       40
       +
           in

     

       41
       41
       +
           map ~kind:"Feed" make

     

       42
       42
       +
           |> mem "type" string ~enc:(fun f -> feed_type_to_string f.feed_type)

     

       43
       43
       +
           |> mem "url" string ~enc:(fun f -> f.url)

     

       44
       44
       +
           |> opt_mem "name" string ~enc:(fun f -> f.name)

     

       45
       45
       +
           |> finish

     

       46
       46
       +
       

     

       47
       47
       +
         let pp ppf t =

     

       48
       48
       +
           let open Fmt in

     

       49
       49
       +
           pf ppf "%s: %s%a"

     

       50
       50
       +
             (feed_type_to_string t.feed_type)

     

       51
       51
       +
             t.url

     

       52
       52
       +
             (option (fun ppf name -> pf ppf " (%s)" name)) t.name

     

       53
       53
       +
       end

     

       54
       54
       +
       

     

       1
       55
        
       module Contact = struct

     

       2
       56
        
         type t = {

     

       3
       57
        
           handle : string;

     
···

       10
       64
        
           mastodon : string option;

     

       11
       65
        
           orcid : string option;

     

       12
       66
        
           url : string option;

     

       13
       13
       -
           atom_feeds : string list option;

     

       67
       67
       +
           feeds : Feed.t list option;

     

       14
       68
        
         }

     

       15
       69
        
       

     

       16
       70
        
         let make ~handle ~names ?email ?icon ?github ?twitter ?bluesky ?mastodon

     

       17
       17
       -
                  ?orcid ?url ?atom_feeds () =

     

       71
       71
       +
                  ?orcid ?url ?feeds () =

     

       18
       72
        
           { handle; names; email; icon; github; twitter; bluesky; mastodon;

     

       19
       19
       -
             orcid; url; atom_feeds }

     

       73
       73
       +
             orcid; url; feeds }

     

       20
       74
        
       

     

       21
       75
        
         let handle t = t.handle

     

       22
       76
        
         let names t = t.names

     

       23
       77
        
         let name t = List.hd t.names

     

       78
       78
       +
         let primary_name = name

     

       24
       79
        
         let email t = t.email

     

       25
       80
        
         let icon t = t.icon

     

       26
       81
        
         let github t = t.github

     
···

       29
       84
        
         let mastodon t = t.mastodon

     

       30
       85
        
         let orcid t = t.orcid

     

       31
       86
        
         let url t = t.url

     

       32
       32
       -
         let atom_feeds t = t.atom_feeds

     

       87
       87
       +
         let feeds t = t.feeds

     

       88
       88
       +
       

     

       89
       89
       +
         let add_feed t feed =

     

       90
       90
       +
           let feeds = match t.feeds with

     

       91
       91
       +
             | Some fs -> Some (feed :: fs)

     

       92
       92
       +
             | None -> Some [feed]

     

       93
       93
       +
           in

     

       94
       94
       +
           { t with feeds }

     

       95
       95
       +
       

     

       96
       96
       +
         let remove_feed t url =

     

       97
       97
       +
           let feeds = match t.feeds with

     

       98
       98
       +
             | Some fs -> Some (List.filter (fun f -> Feed.url f <> url) fs)

     

       99
       99
       +
             | None -> None

     

       100
       100
       +
           in

     

       101
       101
       +
           { t with feeds }

     

       33
       102
        
       

     

       34
       103
        
         let best_url t =

     

       35
       104
        
           match t.url with

     
···

       46
       115
        
           let open Jsont in

     

       47
       116
        
           let open Jsont.Object in

     

       48
       117
        
           let mem_opt f v ~enc = mem f v ~dec_absent:None ~enc_omit:Option.is_none ~enc in

     

       49
       49
       -
           let make handle names email icon github twitter bluesky mastodon orcid url atom_feeds =

     

       118
       118
       +
           let make handle names email icon github twitter bluesky mastodon orcid url feeds =

     

       50
       119
        
             { handle; names; email; icon; github; twitter; bluesky; mastodon;

     

       51
       51
       -
               orcid; url; atom_feeds }

     

       120
       120
       +
               orcid; url; feeds }

     

       52
       121
        
           in

     

       53
       122
        
           map ~kind:"Contact" make

     

       54
       123
        
           |> mem "handle" string ~enc:handle

     
···

       61
       130
        
           |> mem_opt "mastodon" (some string) ~enc:mastodon

     

       62
       131
        
           |> mem_opt "orcid" (some string) ~enc:orcid

     

       63
       132
        
           |> mem_opt "url" (some string) ~enc:url

     

       64
       64
       -
           |> mem_opt "atom_feeds" (some (list string)) ~enc:atom_feeds

     

       133
       133
       +
           |> mem_opt "feeds" (some (list Feed.json_t)) ~enc:feeds

     

       65
       134
        
           |> finish

     

       66
       135
        
       

     

       67
       136
        
         let compare a b = String.compare a.handle b.handle

     
···

       102
       171
        
           (match t.icon with

     

       103
       172
        
            | Some i -> pf ppf "%a: %a@," (styled `Bold string) "Icon" string i

     

       104
       173
        
            | None -> ());

     

       105
       105
       -
           (match t.atom_feeds with

     

       174
       174
       +
           (match t.feeds with

     

       106
       175
        
            | Some feeds when feeds <> [] ->

     

       107
       107
       -
               pf ppf "%a: @[<h>%a@]@," (styled `Bold string) "Atom Feeds"

     

       108
       108
       -
                 (list ~sep:comma string) feeds

     

       176
       176
       +
               pf ppf "%a:@," (styled `Bold string) "Feeds";

     

       177
       177
       +
               List.iter (fun feed ->

     

       178
       178
       +
                 pf ppf "  - %a@," Feed.pp feed

     

       179
       179
       +
               ) feeds

     

       109
       180
        
            | _ -> ());

     

       110
       181
        
           pf ppf "@]"

     

       111
       182
        
       end

     
···

       280
       351
        
           let with_github = List.filter (fun c -> Contact.github c <> None) contacts |> List.length in

     

       281
       352
        
           let with_orcid = List.filter (fun c -> Contact.orcid c <> None) contacts |> List.length in

     

       282
       353
        
           let with_url = List.filter (fun c -> Contact.url c <> None) contacts |> List.length in

     

       283
       283
       -
           let with_feeds = List.filter (fun c -> Contact.atom_feeds c <> None) contacts |> List.length in

     

       354
       354
       +
           let with_feeds = List.filter (fun c -> Contact.feeds c <> None) contacts |> List.length in

     

       355
       355
       +
           let total_feeds = List.fold_left (fun acc c ->

     

       356
       356
       +
             match Contact.feeds c with

     

       357
       357
       +
             | Some feeds -> acc + List.length feeds

     

       358
       358
       +
             | None -> acc

     

       359
       359
       +
           ) 0 contacts in

     

       284
       360
        
       

     

       285
       361
        
           Logs.app (fun m -> m "Contact Database Statistics:");

     

       286
       362
        
           Logs.app (fun m -> m "  Total contacts: %d" total);

     
···

       288
       364
        
           Logs.app (fun m -> m "  With GitHub: %d (%.1f%%)" with_github (float_of_int with_github /. float_of_int total *. 100.));

     

       289
       365
        
           Logs.app (fun m -> m "  With ORCID: %d (%.1f%%)" with_orcid (float_of_int with_orcid /. float_of_int total *. 100.));

     

       290
       366
        
           Logs.app (fun m -> m "  With URL: %d (%.1f%%)" with_url (float_of_int with_url /. float_of_int total *. 100.));

     

       291
       291
       -
           Logs.app (fun m -> m "  With Atom feeds: %d (%.1f%%)" with_feeds (float_of_int with_feeds /. float_of_int total *. 100.));

     

       367
       367
       +
           Logs.app (fun m -> m "  With feeds: %d (%.1f%%), total %d feeds" with_feeds (float_of_int with_feeds /. float_of_int total *. 100.) total_feeds);

     

       292
       368
        
           0

     

       293
       369
        
       

     

       294
       370
        
         (* Command info objects *)

+63 -5

stack/sortal/lib/sortal.mli

···

       29
       29
        
           ]}

     

       30
       30
        
       *)

     

       31
       31
        
       

     

       32
       32
       +
       (** {1 Feed Metadata} *)

     

       33
       33
       +
       

     

       34
       34
       +
       module Feed : sig

     

       35
       35
       +
         (** Feed subscription with type and URL.

     

       36
       36
       +
       

     

       37
       37
       +
             A feed represents a subscription to a content source (Atom, RSS, or JSONFeed). *)

     

       38
       38
       +
         type t

     

       39
       39
       +
       

     

       40
       40
       +
         (** Feed type identifier. *)

     

       41
       41
       +
         type feed_type =

     

       42
       42
       +
           | Atom  (** Atom feed format *)

     

       43
       43
       +
           | Rss   (** RSS feed format *)

     

       44
       44
       +
           | Json  (** JSON Feed format *)

     

       45
       45
       +
       

     

       46
       46
       +
         (** [make ~feed_type ~url ?name ()] creates a new feed.

     

       47
       47
       +
       

     

       48
       48
       +
             @param feed_type The type of feed (Atom, RSS, or JSON)

     

       49
       49
       +
             @param url The feed URL

     

       50
       50
       +
             @param name Optional human-readable name/label for the feed

     

       51
       51
       +
             *)

     

       52
       52
       +
         val make : feed_type:feed_type -> url:string -> ?name:string -> unit -> t

     

       53
       53
       +
       

     

       54
       54
       +
         (** [feed_type t] returns the feed type. *)

     

       55
       55
       +
         val feed_type : t -> feed_type

     

       56
       56
       +
       

     

       57
       57
       +
         (** [url t] returns the feed URL. *)

     

       58
       58
       +
         val url : t -> string

     

       59
       59
       +
       

     

       60
       60
       +
         (** [name t] returns the feed name if set. *)

     

       61
       61
       +
         val name : t -> string option

     

       62
       62
       +
       

     

       63
       63
       +
         (** [set_name t name] returns a new feed with the name updated. *)

     

       64
       64
       +
         val set_name : t -> string -> t

     

       65
       65
       +
       

     

       66
       66
       +
         (** [feed_type_to_string ft] converts a feed type to a string. *)

     

       67
       67
       +
         val feed_type_to_string : feed_type -> string

     

       68
       68
       +
       

     

       69
       69
       +
         (** [feed_type_of_string s] parses a feed type from a string.

     

       70
       70
       +
             Returns [None] if the string is not recognized. *)

     

       71
       71
       +
         val feed_type_of_string : string -> feed_type option

     

       72
       72
       +
       

     

       73
       73
       +
         (** [json_t] is the jsont encoder/decoder for feeds. *)

     

       74
       74
       +
         val json_t : t Jsont.t

     

       75
       75
       +
       

     

       76
       76
       +
         (** [pp ppf t] pretty prints a feed. *)

     

       77
       77
       +
         val pp : Format.formatter -> t -> unit

     

       78
       78
       +
       end

     

       79
       79
       +
       

     

       32
       80
        
       (** {1 Contact Metadata} *)

     

       33
       81
        
       

     

       34
       82
        
       module Contact : sig

     
···

       39
       87
        
         type t

     

       40
       88
        
       

     

       41
       89
        
         (** [make ~handle ~names ?email ?icon ?github ?twitter ?bluesky ?mastodon

     

       42
       42
       -
                 ?orcid ?url ?atom_feeds ()] creates a new contact.

     

       90
       90
       +
                 ?orcid ?url ?feeds ()] creates a new contact.

     

       43
       91
        
       

     

       44
       92
        
             @param handle A unique identifier/username for this contact (required)

     

       45
       93
        
             @param names A list of names for this contact, with the first being primary (required)

     
···

       51
       99
        
             @param mastodon Mastodon handle (including instance)

     

       52
       100
        
             @param orcid ORCID identifier

     

       53
       101
        
             @param url Personal or professional website URL

     

       54
       54
       -
             @param atom_feeds List of Atom/RSS feed URLs associated with this contact

     

       102
       102
       +
             @param feeds List of feed subscriptions (Atom/RSS/JSON) associated with this contact

     

       55
       103
        
             *)

     

       56
       104
        
         val make :

     

       57
       105
        
           handle:string ->

     
···

       64
       112
        
           ?mastodon:string ->

     

       65
       113
        
           ?orcid:string ->

     

       66
       114
        
           ?url:string ->

     

       67
       67
       -
           ?atom_feeds:string list ->

     

       115
       115
       +
           ?feeds:Feed.t list ->

     

       68
       116
        
           unit ->

     

       69
       117
        
           t

     

       70
       118
        
       

     
···

       79
       127
        
         (** [name t] returns the primary (first) name. *)

     

       80
       128
        
         val name : t -> string

     

       81
       129
        
       

     

       130
       130
       +
         (** [primary_name t] returns the primary (first) name.

     

       131
       131
       +
             This is an alias for {!name} for clarity. *)

     

       132
       132
       +
         val primary_name : t -> string

     

       133
       133
       +
       

     

       82
       134
        
         (** [email t] returns the email address if available. *)

     

       83
       135
        
         val email : t -> string option

     

       84
       136
        
       

     
···

       103
       155
        
         (** [url t] returns the personal/professional website URL if available. *)

     

       104
       156
        
         val url : t -> string option

     

       105
       157
        
       

     

       106
       106
       -
         (** [atom_feeds t] returns the list of Atom/RSS feed URLs if available. *)

     

       107
       107
       -
         val atom_feeds : t -> string list option

     

       158
       158
       +
         (** [feeds t] returns the list of feed subscriptions if available. *)

     

       159
       159
       +
         val feeds : t -> Feed.t list option

     

       160
       160
       +
       

     

       161
       161
       +
         (** [add_feed t feed] returns a new contact with the feed added. *)

     

       162
       162
       +
         val add_feed : t -> Feed.t -> t

     

       163
       163
       +
       

     

       164
       164
       +
         (** [remove_feed t url] returns a new contact with the feed matching the URL removed. *)

     

       165
       165
       +
         val remove_feed : t -> string -> t

     

       108
       166
        
       

     

       109
       167
        
         (** {2 Derived Information} *)

     

       110
       168

+36 -2

stack/sortal/scripts/import_yaml_contacts.py

···

       31
       31
        
                   return yaml.safe_load(yaml_content)

     

       32
       32
        
           return None

     

       33
       33
        
       

     

       34
       34
       +
       def detect_feed_type(url):

     

       35
       35
       +
           """Detect feed type based on URL patterns."""

     

       36
       36
       +
           url_lower = url.lower()

     

       37
       37
       +
           if 'json' in url_lower or url_lower.endswith('.json'):

     

       38
       38
       +
               return 'json'

     

       39
       39
       +
           elif 'rss' in url_lower or url_lower.endswith('.rss') or url_lower.endswith('.xml'):

     

       40
       40
       +
               return 'rss'

     

       41
       41
       +
           else:

     

       42
       42
       +
               # Default to atom for most feeds

     

       43
       43
       +
               return 'atom'

     

       44
       44
       +
       

     

       34
       45
        
       def convert_to_sortal_format(yaml_data, handle):

     

       35
       46
        
           """Convert YAML contact data to Sortal JSON format."""

     

       36
       47
        
           sortal_contact = {

     
···

       55
       66
        
               sortal_contact["orcid"] = yaml_data["orcid"]

     

       56
       67
        
           if "url" in yaml_data:

     

       57
       68
        
               sortal_contact["url"] = yaml_data["url"]

     

       69
       69
       +
       

     

       70
       70
       +
           # Convert atom feeds to new feed structure

     

       58
       71
        
           if "atom" in yaml_data:

     

       59
       59
       -
               sortal_contact["atom_feeds"] = yaml_data["atom"]

     

       72
       72
       +
               atom_feeds = yaml_data["atom"]

     

       73
       73
       +
               if atom_feeds:

     

       74
       74
       +
                   feeds = []

     

       75
       75
       +
                   for feed_url in atom_feeds:

     

       76
       76
       +
                       feed_type = detect_feed_type(feed_url)

     

       77
       77
       +
                       feed_obj = {

     

       78
       78
       +
                           "type": feed_type,

     

       79
       79
       +
                           "url": feed_url

     

       80
       80
       +
                       }

     

       81
       81
       +
                       feeds.append(feed_obj)

     

       82
       82
       +
                   sortal_contact["feeds"] = feeds

     

       60
       83
        
       

     

       61
       84
        
           return sortal_contact

     

       62
       85
        
       

     
···

       77
       100
        
               print(f"Error: Source directory does not exist: {source_dir}")

     

       78
       101
        
               return 1

     

       79
       102
        
       

     

       103
       103
       +
           # Delete existing contacts to avoid old schema

     

       104
       104
       +
           print("Clearing existing contacts...")

     

       105
       105
       +
           for existing_file in dest_dir.glob('*.json'):

     

       106
       106
       +
               existing_file.unlink()

     

       107
       107
       +
       

     

       80
       108
        
           imported_count = 0

     

       81
       109
        
           error_count = 0

     

       110
       110
       +
           total_feeds = 0

     

       82
       111
        
       

     

       83
       112
        
           # Process each .md file

     

       84
       113
        
           for md_file in sorted(source_dir.glob('*.md')):

     
···

       100
       129
        
                       json.dump(sortal_contact, f, indent=2, ensure_ascii=False)

     

       101
       130
        
       

     

       102
       131
        
                   name = sortal_contact.get('names', [handle])[0] if sortal_contact.get('names') else handle

     

       103
       103
       -
                   print(f"✓ Imported: {handle} ({name})")

     

       132
       132
       +
                   feed_count = len(sortal_contact.get('feeds', []))

     

       133
       133
       +
                   total_feeds += feed_count

     

       134
       134
       +
       

     

       135
       135
       +
                   feed_info = f" ({feed_count} feed{'s' if feed_count != 1 else ''})" if feed_count > 0 else ""

     

       136
       136
       +
                   print(f"✓ Imported: {handle} ({name}){feed_info}")

     

       104
       137
        
                   imported_count += 1

     

       105
       138
        
       

     

       106
       139
        
               except Exception as e:

     
···

       110
       143
        
           print()

     

       111
       144
        
           print(f"Import complete!")

     

       112
       145
        
           print(f"  Successfully imported: {imported_count}")

     

       146
       146
       +
           print(f"  Total feeds: {total_feeds}")

     

       113
       147
        
           print(f"  Errors: {error_count}")

     

       114
       148
        
           print(f"  Output directory: {dest_dir}")

     

       115
       149