fixes and formatting

Author: Affie

ext/BlobArrow.jl

@@ -2,7 +2,7 @@ module BlobArrow
 
 using Arrow
 using DistributedFactorGraphs
-using DistributedFactorGraphs: _MIMEOverrides, format_to_mime
+using DistributedFactorGraphs: _MIMEOverrides, getMimetype
 
 function __init__()
     @info "Including Arrow blobs support in DFG."
@@ -15,7 +15,7 @@ function DFG.packBlob(::Type{format"Arrow"}, data; kwargs...)
     io = IOBuffer()
     Arrow.write(io, data; kwargs...)
     blob = take!(io)
-    mimetype = format_to_mime(format"Arrow")
+    mimetype = getMimetype(format"Arrow")
     return blob, mimetype
 end
 

src/Common.jl

@@ -214,7 +214,7 @@ function Timestamp(epoch::Val{:unix}, t::Float64, zone = tz"UTC")
 end
 Timestamp(t::Float64, zone = tz"UTC") = Timestamp(Val(:unix), t, zone)
 function Timestamp(epoch::Val{:rata}, t::Float64, zone = tz"UTC")
-    return TimeDateZone(convert(DateTime, Millisecond(t*10^3)), zone)
+    return TimeDateZone(convert(DateTime, Millisecond(t * 10^3)), zone)
 end
 
 function now_tdz(zone = tz"UTC")

src/DataBlobs/entities/BlobEntry.jl

@@ -20,23 +20,23 @@ StructUtils.@kwarg struct Blobentry
     """ (Optional) crc32c hash value to ensure data consistency which must correspond to the stored hash upon retrieval."""
     crchash::Union{UInt32, Nothing} =
         nothing & (
-            json=(
-                lower = h->isnothing(h) ? nothing : string(h, base = 16),
-                lift = s->isnothing(s) ? nothing : parse(UInt32, s; base = 16),
+            json = (
+                lower = h -> isnothing(h) ? nothing : string(h; base = 16),
+                lift = s -> isnothing(s) ? nothing : parse(UInt32, s; base = 16),
             )
         )
     """ (Optional) sha256 hash value to ensure data consistency which must correspond to the stored hash upon retrieval."""
     shahash::Union{Vector{UInt8}, Nothing} =
         nothing & (
-            json=(
-                lower = h->isnothing(h) ? nothing : bytes2hex(h),
-                lift = s->isnothing(s) ? nothing : hex2bytes(s),
+            json = (
+                lower = h -> isnothing(h) ? nothing : bytes2hex(h),
+                lift = s -> isnothing(s) ? nothing : hex2bytes(s),
             )
         )
     """ Source system or application where the blob was created (e.g., webapp, sdk, robot)"""
     origin::String = ""
     """Number of bytes in blob serialized as a string"""
-    size::Int64 = -1 & (json=(lower = string, lift = x->parse(Int64, x)))
+    size::Int64 = -1 & (json = (lower = string, lift = x -> parse(Int64, x)))
     """ Additional information that can help a different user of the Blob. """
     description::String = ""
     """ MIME description describing the format of binary data in the `Blob`, e.g. 'image/png' or 'application/json'. """

src/DataBlobs/services/BlobPacking.jl

@@ -12,19 +12,19 @@ const _MIMEOverrides = OrderedDict{DataType, MIME}(
 )
 
 """
-    format_to_mime(::Type{DataFormat{S}}) -> MIME
+    getMimetype(::Type{DataFormat{S}}) -> MIME
 
 Get the MIME type for a FileIO `DataFormat`. Uses FileIO's extension registry
 and MIMEs.jl for standard types, falls back to `_MIMEOverrides` for
 domain-specific formats.
 
 # Examples
 ```julia
-format_to_mime(format"PNG")  # MIME("image/png")
-format_to_mime(format"JSON") # MIME("application/json")
+getMimetype(format"PNG")  # MIME("image/png")
+getMimetype(format"JSON") # MIME("application/json")
 ```
 """
-function format_to_mime(::Type{DataFormat{S}}) where {S}
+function getMimetype(::Type{DataFormat{S}}) where {S}
     T = DataFormat{S}
     haskey(_MIMEOverrides, T) && return _MIMEOverrides[T]
     try
@@ -39,7 +39,7 @@ function format_to_mime(::Type{DataFormat{S}}) where {S}
 end
 
 """
-    mime_to_format(::MIME) -> Union{Type{DataFormat{S}}, Nothing}
+    getDataFormat(::MIME) -> Union{Type{DataFormat{S}}, Nothing}
 
 Get the FileIO `DataFormat` for a MIME type. Uses MIMEs.jl and FileIO's extension
 registry, falls back to `_MIMEOverrides`.
@@ -48,11 +48,11 @@ Returns `nothing` if no matching format is found.
 
 # Examples
 ```julia
-mime_to_format(MIME("image/png"))        # format"PNG"
-mime_to_format(MIME("application/json")) # format"JSON"
+getDataFormat(MIME("image/png"))        # format"PNG"
+getDataFormat(MIME("application/json")) # format"JSON"
 ```
 """
-function mime_to_format(m::MIME)
+function getDataFormat(m::MIME)
     for (fmt, mime) in _MIMEOverrides
         mime == m && return fmt
     end
@@ -78,14 +78,14 @@ function unpackBlob end
 unpackBlob(mime::String, blob) = unpackBlob(MIME(mime), blob)
 
 function unpackBlob(T::MIME, blob)
-    dataformat = mime_to_format(T)
+    dataformat = getDataFormat(T)
     isnothing(dataformat) && error("Format not found for MIME type $(T)")
     return unpackBlob(dataformat, blob)
 end
 
 # 1. JSON strings are saved as is
 function packBlob(::Type{format"JSON"}, json_str::String)
-    mimetype = format_to_mime(format"JSON")
+    mimetype = getMimetype(format"JSON")
     blob = Vector{UInt8}(json_str)
     return blob, mimetype
 end
@@ -102,7 +102,7 @@ function packBlob(::Type{T}, data::Any; kwargs...) where {T <: DataFormat}
     io = IOBuffer()
     save(Stream{T}(io), data; kwargs...)
     blob = take!(io)
-    mimetype = format_to_mime(T)
+    mimetype = getMimetype(T)
     return blob, mimetype
 end
 
@@ -119,5 +119,5 @@ Detect the MIME type of data in an IO stream using FileIO's format detection.
 function getMimetype(io::IO)
     _getFormat(s::FileIO.Stream{T}) where {T} = T
     stream = FileIO.query(io)
-    return format_to_mime(_getFormat(stream))
+    return getMimetype(_getFormat(stream))
 end

src/DataBlobs/services/BlobWrappers.jl

@@ -231,19 +231,19 @@ function saveImage_Variable!(
     blobstore::Symbol = :default;
     entry_kwargs...,
 )
-    mimeType = get(entry_kwargs, :mimeType, MIME("image/png"))
-    format = mime_to_format(mimeType)
+    mimetype = get(entry_kwargs, :mimeType, MIME("image/png"))
+    format = getDataFormat(mimetype)
+    isnothing(format) &&
+        throw(ArgumentError("Unsupported MIME type for image: $(mimetype)"))
+    blob, mimetype = packBlob(format, img)
 
-    blob, mimeType = packBlob(format, img)
-
-    size = string(length(blob))
     entry = Blobentry(
         entry_label,
         blobstore;
         blobid = uuid4(),
         entry_kwargs...,
-        size,
-        mimeType = string(mimeType),
+        size = length(blob),
+        mimetype,
     )
 
     return saveBlob_Variable!(dfg, variable_label, blob, entry)

src/DistributedFactorGraphs.jl

@@ -479,8 +479,8 @@ const unstable_functions::Vector{Symbol} = [
     :packBlob,
     :hasTags,
     :unpackBlob,
-    :format_to_mime,
-    :mime_to_format,
+    :getMimetype,
+    :getDataFormat,
     :getMimetype,
     :emptyTags!,
     :ls,

src/FileDFG/services/FileDFG.jl

@@ -119,7 +119,7 @@ function loadDFG!(
     variablefiles = readdir(joinpath(loaddir, "variables"); sort = false, join = true)
 
     # type instability on `variables` as either `::Vector{Variable}` or `::Vector{VariableDFG{<:}}` (vector of abstract)
-    variables = @showprogress dt=1 desc = "loading variables" asyncmap(
+    variables = @showprogress dt = 1 desc = "loading variables" asyncmap(
         variablefiles,
     ) do file
         v = JSON.parsefile(file, V; style = DFGJSONStyle())
@@ -130,7 +130,7 @@ function loadDFG!(
 
     factorfiles = readdir(joinpath(loaddir, "factors"); sort = false, join = true)
 
-    factors = @showprogress dt=1 desc = "loading factors" asyncmap(factorfiles) do file
+    factors = @showprogress dt = 1 desc = "loading factors" asyncmap(factorfiles) do file
         f = JSON.parsefile(file, F; style = DFGJSONStyle())
         return addFactor!(dfgLoadInto, f)
     end
@@ -139,7 +139,7 @@ function loadDFG!(
 
     if isa(dfgLoadInto, GraphsDFG) && getTypeDFGFactors(dfgLoadInto) <: FactorDFG
         # Finally, rebuild the CCW's for the factors to completely reinflate them
-        @showprogress dt=1 desc = "Rebuilding factor solver cache" for factor in factors
+        @showprogress dt = 1 desc = "Rebuilding factor solver cache" for factor in factors
             rebuildFactorCache!(dfgLoadInto, factor)
         end
     end

src/GraphsDFG/services/GraphsDFG.jl

@@ -239,8 +239,8 @@ function listNeighbors(
 
     # Additional filtering
     # solvable != 0 && filter!(lbl -> _isSolvable(dfg, lbl, solvable), neighbors_ll)
-    filterDFG!(neighbors_ll, solvableFilter, l->getSolvable(dfg, l))
-    filterDFG!(neighbors_ll, tagsFilter, l->listTags(dfg, l))
+    filterDFG!(neighbors_ll, solvableFilter, l -> getSolvable(dfg, l))
+    filterDFG!(neighbors_ll, tagsFilter, l -> listTags(dfg, l))
 
     # Variable sorting (order is important)
     if haskey(dfg.g.factors, label)
@@ -278,8 +278,8 @@ function listNeighborhood(
 
     allvarfacs = [dfg.g.labels[id] for id in nbhood]
 
-    filterDFG!(allvarfacs, solvableFilter, l->getSolvable(dfg, l))
-    filterDFG!(allvarfacs, tagsFilter, l->listTags(dfg, l))
+    filterDFG!(allvarfacs, solvableFilter, l -> getSolvable(dfg, l))
+    filterDFG!(allvarfacs, tagsFilter, l -> listTags(dfg, l))
 
     variableLabels = intersect(listVariables(dfg), allvarfacs)
     factorLabels = intersect(listFactors(dfg), allvarfacs)

src/entities/DFGFactor.jl

@@ -65,7 +65,7 @@ StructUtils.@kwarg struct FactorDFG{T <: AbstractObservation, N} <: AbstractGrap
     tags::Set{Symbol} = Set{Symbol}([:FACTOR])
     """Ordered list of the neighbor variables.
     Accessors: [`getVariableOrder`](@ref)"""
-    variableorder::NTuple{N, Symbol} & (choosetype = x->NTuple{length(x), Symbol},) # NOTE v0.29 renamed from _variableOrderSymbols
+    variableorder::NTuple{N, Symbol} & (choosetype = x -> NTuple{length(x), Symbol},) # NOTE v0.29 renamed from _variableOrderSymbols
     """Variable timestamp.
     Accessors: [`getTimestamp`](@ref)"""
     timestamp::TimeDateZone = now_tdz() # NOTE v0.29 changed from ZonedDateTime
@@ -307,7 +307,7 @@ $(TYPEDFIELDS)
     tags::Set{Symbol}
     """Ordered list of the neighbor variables.
     Accessors: [`getVariableOrder`](@ref)"""
-    variableorder::Tuple{Vararg{Symbol}} & (choosetype = x->NTuple{length(x), Symbol},) #TODO changed to NTuple
+    variableorder::Tuple{Vararg{Symbol}} & (choosetype = x -> NTuple{length(x), Symbol},) #TODO changed to NTuple
     """Variable timestamp.
     Accessors: [`getTimestamp`](@ref)"""
     timestamp::TimeDateZone
@@ -348,7 +348,7 @@ $(TYPEDFIELDS)
     tags::Set{Symbol}
     """Ordered list of the neighbor variables.
     Accessors: [`getVariableOrder`](@ref)"""
-    variableorder::Tuple{Vararg{Symbol}} & (choosetype = x->NTuple{length(x), Symbol},)
+    variableorder::Tuple{Vararg{Symbol}} & (choosetype = x -> NTuple{length(x), Symbol},)
 end
 
 ##------------------------------------------------------------------------------

src/services/AbstractDFG.jl

@@ -276,7 +276,7 @@ Implement `mergeVariable!(dfg::AbstractDFG, variable::AbstractGraphVariable)`
 function mergeVariable! end
 
 function mergeVariables!(dfg::AbstractDFG, variables::Vector{<:AbstractGraphVariable})
-    counts = asyncmap(v->mergeVariable!(dfg, v), variables)
+    counts = asyncmap(v -> mergeVariable!(dfg, v), variables)
     return sum(counts; init = 0)
 end
 
@@ -289,7 +289,7 @@ Implement `mergeFactor!(dfg::AbstractDFG, factor::AbstractGraphFactor)`
 function mergeFactor! end
 
 function mergeFactors!(dfg::AbstractDFG, factors::Vector{<:AbstractGraphFactor})
-    counts = asyncmap(f->mergeFactor!(dfg, f), factors)
+    counts = asyncmap(f -> mergeFactor!(dfg, f), factors)
     return sum(counts; init = 0)
 end