defmodule Noizu.Weaviate.GraphQL.Additional do
defmodule Classification do
defstruct [
properties: []
]
def classification(properties) do
properties = (is_list(properties) && properties || [properties])
|> Enum.filter(fn(p) -> p in [:id, :classified_fields, :based_on, :completed, :scope] end)
unless properties == [] do
%__MODULE__{
properties: properties
}
end
end
defimpl Jason.Encoder do
@lookup %{
id: "id",
scope: "scope",
completed: "completed",
based_on: "basedOn",
classified_fields: "classifiedFields"
}
def encode(this, opts) do
properties = Enum.map(this.properties, &(@lookup[&1]))
|> Enum.join("\n ")
encoded = """
classification {
#{properties}
}
""" |> String.trim()
end
end
end
defmodule FeatureProjection do
defstruct [
dimensions: 2,
algorithm: nil,
perplexity: nil,
learning_rate: nil,
iterations: nil,
properties: [:vector]
]
def feature_projection(options) do
%__MODULE__{
dimensions: options[:dimensions] || 2,
algorithm: options[:algorithm],
perplexity: options[:perplexity],
learning_rate: options[:learning_rate],
iterations: options[:iterations]
}
end
defimpl Jason.Encoder do
@lookup %{
vector: "vector",
}
def encode(this, opts) do
properties = Enum.map(this.properties, &(@lookup[&1]))
|> Enum.join("\n ")
options =
[]
|> then(& this.dimensions && [{:dimensions, this.dimensions}|&1] || &1 )
|> then(& this.algorithm && [{:algorithm, this.algorithm}|&1] || &1 )
|> then(& this.perplexity && [{:perplexity, this.perplexity}|&1] || &1 )
|> then(& this.learning_rate && [{:learningRate, this.learning_rate}|&1] || &1 )
|> then(& this.iterations && [{:iterations, this.iterations}|&1] || &1 )
|> Enum.map(fn({k,v}) -> "#{k}: #{inspect v}" end)
|> Enum.join(", ")
encoded = """
featureProjection(#{options}) {
#{properties}
}
""" |> String.trim()
end
end
end
defstruct [
properties: [],
]
def additional(properties) do
properties = cond do
is_list(properties) -> properties
:else -> [properties]
end
%__MODULE__{properties: properties}
end
defimpl Jason.Encoder do
@lookup %{
id: "id",
vector: "vector",
generate: "generate",
rerank: "rerank",
creation_time: "creationTimeUnix",
last_update_time: "lastUpdateTimeUnix",
distance: "distance",
}
def encode(this, opts) do
contents = Enum.map(this.properties,
fn
(property) when property in [:id, :vector, :generate, :rerank, :creation_time, :last_update_time, :distance] -> @lookup[property]
(property = %FeatureProjection{}) -> Jason.encode!(property)
(property = %Classification{}) -> Jason.encode!(property)
(_) -> nil
end)
|> Enum.reject(&is_nil/1)
|> Enum.join("\n ")
"""
_additional {
#{contents}
}
""" |> String.trim()
end
end
end