add metadata(pkg); WIP

Author: ablaom

src/MLJModelRegistry.jl

@@ -13,5 +13,6 @@ const REGISTRY = joinpath(ROOT, "registry")
 include("GenericRegistry.jl")
 include("check_traits.jl")
 include("remote_methods.jl")
+include("methods.jl")
 
 end # module

src/check_traits.jl

@@ -0,0 +1,39 @@
+# TODO: This method should live at MLJModelInterface !
+
+ismissing_or_isa(x, T) = ismissing(x) || x isa T
+
+function check_traits(M)
+    message = "$M has a bad trait declaration.\n"
+    ismissing_or_isa(MLJModelInterface.is_pure_julia(M), Bool) ||
+        error(message*"`is_pure_julia` must return true or false")
+    ismissing_or_isa(MLJModelInterface.supports_weights(M), Bool) ||
+        error(message*"`supports_weights` must return `true`, "*
+        "`false` or `missing`. ")
+    ismissing_or_isa(MLJModelInterface.supports_class_weights(M), Bool) ||
+        error(message*"`supports_class_weights` must return `true`, "*
+            "`false` or `missing`. ")
+    MLJModelInterface.is_wrapper(M) isa Bool ||
+        error(message*"`is_wrapper` must return `true` or `false`. ")
+    load_path = MLJModelInterface.load_path(M)
+    load_path isa String ||
+        error(message*"`load_path` must return a `String`. ")
+    contains(load_path, "unknown") &&
+        error(message*"`load_path` return value contains string \"unknown\". ")
+    pkg = MLJModelInterface.package_name(M)
+    pkg isa String || error(message*"`package_name` must return a `String`. ")
+    api_pkg = split(load_path, '.') |> first
+    pkg == "unknown" && error(message*"`package_name` returns \"unknown\". ")
+    load_path_ex = Meta.parse(load_path)
+    api_pkg_ex = Symbol(api_pkg)
+    import_ex = :(import $api_pkg_ex)
+    program_to_test_load_path = quote
+        $import_ex
+        $load_path_ex
+    end
+    try
+        Main.eval(program_to_test_load_path)
+    catch excptn
+        error(message*"Cannot import value of `load_path` (parsed as expression). ")
+        rethrow(excptn)
+    end
+end

src/methods.jl

@@ -0,0 +1,44 @@
+const DOC_ADDING_PACKAGES = """
+
+    Use Julia's package manager, `Pkg`, to add a new model-providing package to the
+    environment at "/registry/". This is necessary before model medata can be generated
+    and recorded.
+
+    IMPORTANT: In any pull request to update the Model Registry you should note the final
+    output of `Pkg.status(outdated=true)`.
+
+    In detail, you will generally perform the following steps to add the new package:
+
+    1. In your local clone of MLJModelRegistry.jl, `activate` the environment at  "/registry/".
+
+    2. `update` the environment
+
+    3. Note the output of `Pkg.status(outdated=true)`
+
+    3. `add` the new package
+
+    4. Repeat steps 2 and 3 above, and investigate any dependeny downgrades for which your addition may be responsible.
+
+    If adding the new package results in downgrades to existing dependencies, your pull
+    request to register the new models may be rejected.
+
+    """
+
+err_missing_package(pkg) = ArgumentError("""
+    The package \"$pkg\" could not be found in the model registry. $DOC_ADDING_PACKAGES
+    """
+)
+
+function metadata(pkg)
+    pkg in GenericRegistry.dependencies(REGISTRY) || throw(err_missing_package(pkg))
+    setup = quote
+        # REMOVE THIS NEXT LINE AFTER TAGGING NEW MLJMODELINTERFACE
+        Pkg.develop(path="/Users/anthony/MLJ/MLJModelInterface/")
+        Pkg.develop(path=$ROOT)
+    end
+    program = quote
+        import MLJModelRegistry
+        MLJModelRegistry.traits_given_constructor_name()
+    end
+    return GenericRegistry.run(setup, pkg, program)
+end

src/remote_methods.jl

@@ -0,0 +1,110 @@
+# Remote methods are methods called on remote processes for the purpose of when extacting
+# model metadata for a package
+
+
+# # HELPERS
+
+function finaltypes(T::Type)
+    s = InteractiveUtils.subtypes(T)
+    if isempty(s)
+        return [T, ]
+    else
+        return reduce(vcat, [finaltypes(S) for S in s])
+    end
+end
+
+"""
+    model_type_given_constructor(modeltypes)
+
+**Private method.**
+
+Return a dictionary of `modeltypes`, keyed on constructor. Where multiple types share a
+single constructor, there can only be one value (and which value appears is not
+predictable).
+
+Typically a model type and it's constructor have the same name, but for wrappers, such as
+`TunedModel`, several types share the same constructor (e.g., `DeterministicTunedModel`,
+`ProbabilisticTunedModel` are model types sharing constructor `TunedModel`).
+
+"""
+function modeltype_given_constructor(modeltypes)
+
+    # Note that wrappers are required to overload `MLJModelInterface.constructor` and the
+    # fallback is `nothing`.
+
+    return Dict(
+        map(modeltypes) do M
+            C =  MLJModelInterface.constructor(M)
+            Pair(isnothing(C) ? M : C, M)
+        end...,
+    )
+end
+
+"""
+    encode_dic(d)
+
+Convert an arbitrary nested dictionary `d` into a nested dictionary whose leaf values are
+all strings, suitable for writing to a TOML file (a poor man's serialization). The rules
+for converting leaves are:
+
+1. If it's a `Symbol`, preserve the colon, as in :x -> ":x"
+
+2. If it's an `AbstractString`, apply `string` function (e.g, to remove `SubString`s)
+
+3. In all other cases, except `AbstractArray`s, wrap in single quotes, as in sum -> "`sum`"
+
+4. Replace any `#` character in the application of Rule 3 with `_` (to handle `gensym` names)
+
+5. For an `AbstractVector`, broadcast the preceding Rules over its elements.
+
+"""
+function encode_dic(s)
+    prestring = string("`", s, "`")
+    # hack for objects with gensyms in their string representation:
+    str = replace(prestring, '#'=>'_')
+    return str
+end
+encode_dic(s::Symbol) = string(":", s)
+encode_dic(s::AbstractString) = string(s)
+encode_dic(v::AbstractVector) = encode_dic.(v)
+function encode_dic(d::AbstractDict)
+    ret = LittleDict{}()
+    for (k, v) in d
+        ret[encode_dic(k)] = encode_dic(v)
+    end
+    return ret
+end
+
+
+# # REMOTE METHODS
+
+function traits_given_constructor_name()
+
+    # Some explanation for the gymnamstics going on here: The model registry is actually
+    # keyed on constructor names, not model type names, a change from the way the registry
+    # was initially set up. These are usually the same, but wrappers frequently provide
+    # exceptions; e.g., "TunedModel" is a constructor for two model types
+    # "ProbabilisticTunedModel" and "DeterministicTunedModel". Unfortunately, what is easy
+    # to grab are the model type names (we look for subtypes of `Model`) and we get the
+    # constructors after, through the `constructor` trait. Only one
+
+    modeltypes = filter(finaltypes(MLJModelInterface.Model)) do T
+        !(isabstracttype(T))
+    end
+    modeltype_given_constructor = MLJModelRegistry.modeltype_given_constructor(modeltypes)
+    constructors = keys(modeltype_given_constructor) |> collect
+    sort!(constructors, by=string)
+    traits_given_constructor_name = Dict{String,Any}()
+
+    for C in constructors
+        M = modeltype_given_constructor[C]
+        check_traits(M)
+        constructor_name = split(string(C), '.') |> last
+        traits = LittleDict{Symbol,Any}(trait => eval(:(MLJModelInterface.$trait))(M)
+        for trait in MLJModelInterface.MODEL_TRAITS)
+        traits[:name] = constructor_name
+        traits_given_constructor_name[constructor_name] = traits
+    end
+
+    return encode_dic(traits_given_constructor_name)
+end