code
stringlengths 114
1.05M
| path
stringlengths 3
312
| quality_prob
float64 0.5
0.99
| learning_prob
float64 0.2
1
| filename
stringlengths 3
168
| kind
stringclasses 1
value |
|---|---|---|---|---|---|
defmodule Date.Range do
@moduledoc """
Returns an inclusive range between dates.
Ranges must be created with the `Date.range/2` function.
The following fields are public:
* `:first` - the initial date on the range
* `:last` - the last date on the range
The remaining fields are private and should not be accessed.
"""
@type t :: %__MODULE__{
first: Date.t(),
last: Date.t(),
first_in_iso_days: Calendar.iso_days(),
last_in_iso_days: Calendar.iso_days()
}
defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days]
defimpl Enumerable do
def member?(
%{
first: %{calendar: calendar, year: first_year, month: first_month, day: first_day},
last: %{calendar: calendar, year: last_year, month: last_month, day: last_day},
first_in_iso_days: first_in_iso_days,
last_in_iso_days: last_in_iso_days
},
%Date{calendar: calendar, year: year, month: month, day: day}
) do
first = {first_year, first_month, first_day}
last = {last_year, last_month, last_day}
date = {year, month, day}
if first_in_iso_days <= last_in_iso_days do
{:ok, date >= first and date <= last}
else
{:ok, date >= last and date <= first}
end
end
def member?(_, _) do
{:ok, false}
end
def count(%Date.Range{
first_in_iso_days: first_in_iso_days,
last_in_iso_days: last_in_iso_days
}) do
{:ok, abs(first_in_iso_days - last_in_iso_days) + 1}
end
def reduce(
%Date.Range{
first_in_iso_days: first_in_iso_days,
last_in_iso_days: last_in_iso_days,
first: %{calendar: calendar}
},
acc,
fun
) do
reduce(
first_in_iso_days,
last_in_iso_days,
acc,
fun,
calendar,
first_in_iso_days <= last_in_iso_days
)
end
defp reduce(_x, _y, {:halt, acc}, _fun, _calendar, _up?) do
{:halted, acc}
end
defp reduce(x, y, {:suspend, acc}, fun, calendar, up?) do
{:suspended, acc, &reduce(x, y, &1, fun, calendar, up?)}
end
defp reduce(x, y, {:cont, acc}, fun, calendar, up? = true) when x <= y do
reduce(x + 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
end
defp reduce(x, y, {:cont, acc}, fun, calendar, up? = false) when x >= y do
reduce(x - 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
end
defp reduce(_, _, {:cont, acc}, _fun, _calendar, _up) do
{:done, acc}
end
defp date_from_iso_days(days, Calendar.ISO) do
{year, month, day} = Calendar.ISO.date_from_iso_days(days)
%Date{year: year, month: month, day: day, calendar: Calendar.ISO}
end
defp date_from_iso_days(days, calendar) do
{year, month, day, _, _, _, _} =
calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})
%Date{year: year, month: month, day: day, calendar: calendar}
end
end
defimpl Inspect do
def inspect(%Date.Range{first: first, last: last}, _) do
"#DateRange<" <> inspect(first) <> ", " <> inspect(last) <> ">"
end
end
end
|
lib/elixir/lib/calendar/date_range.ex
| 0.860296 | 0.762114 |
date_range.ex
|
starcoder
|
defmodule Sneex.CpuHelper do
@moduledoc "This module defines helper functions for checking CPU flags."
use Bitwise
@doc "
This function will determine new values for several of the CPU flags.
## Examples
iex> 0 |> Sneex.CpuHelper.check_flags_for_value(:bit8)
%{carry: false, negative: false, overflow: false, zero: true}
iex> 0 |> Sneex.CpuHelper.check_flags_for_value(:bit16)
%{carry: false, negative: false, overflow: false, zero: true}
iex> 0x80 |> Sneex.CpuHelper.check_flags_for_value(:bit8)
%{carry: false, negative: true, overflow: false, zero: false}
iex> 0x80 |> Sneex.CpuHelper.check_flags_for_value(:bit16)
%{carry: false, negative: false, overflow: false, zero: false}
iex> 0x7FFF |> Sneex.CpuHelper.check_flags_for_value(:bit16)
%{carry: false, negative: false, overflow: true, zero: false}
iex> 0x8000 |> Sneex.CpuHelper.check_flags_for_value(:bit16)
%{carry: false, negative: true, overflow: false, zero: false}
"
@spec check_flags_for_value(integer(), Sneex.Cpu.bit_size()) :: %{
carry: boolean(),
negative: boolean(),
overflow: boolean(),
zero: boolean()
}
def check_flags_for_value(value, bitness) do
%{
negative: check_negative_flag(value, bitness),
overflow: check_overflow_flag(value, bitness),
zero: check_zero_flag(value),
carry: check_carry_flag(value)
}
end
defp check_negative_flag(value, :bit8) when 0x80 == band(value, 0x80), do: true
defp check_negative_flag(value, :bit16) when 0x8000 == band(value, 0x8000), do: true
defp check_negative_flag(_value, _bitness), do: false
# Still need to figure this out
defp check_overflow_flag(value, :bit8) when 0x40 == band(value, 0x40), do: true
defp check_overflow_flag(value, :bit16) when 0x4000 == band(value, 0x4000), do: true
defp check_overflow_flag(_value, _bitness), do: false
defp check_zero_flag(0), do: true
defp check_zero_flag(_), do: false
# Still need to figure this out
defp check_carry_flag(_value), do: false
@doc "
This function will rotate a value 1 step to the left or right, filling in 0's.
It returns a tuple containing the updated value and the bit that was rotated off the value.
## Examples - Rotating Left
iex> 0 |> Sneex.CpuHelper.rotate(:bit8, :left)
{0, false}
iex> 0 |> Sneex.CpuHelper.rotate(:bit16, :left)
{0, false}
iex> 0x80 |> Sneex.CpuHelper.rotate(:bit8, :left)
{0, true}
iex> 0x80 |> Sneex.CpuHelper.rotate(:bit16, :left)
{0x0100, false}
iex> 0xFF |> Sneex.CpuHelper.rotate(:bit8, :left)
{0xFE, true}
iex> 0xFF |> Sneex.CpuHelper.rotate(:bit16, :left)
{0x01FE, false}
iex> 0x7FFF |> Sneex.CpuHelper.rotate(:bit16, :left)
{0xFFFE, false}
iex> 0x8000 |> Sneex.CpuHelper.rotate(:bit16, :left)
{0, true}
iex> 0xFFFF |> Sneex.CpuHelper.rotate(:bit16, :left)
{0xFFFE, true}
## Examples - Rotating Right
iex> 0 |> Sneex.CpuHelper.rotate(:bit8, :right)
{0, false}
iex> 0 |> Sneex.CpuHelper.rotate(:bit16, :right)
{0, false}
iex> 0x80 |> Sneex.CpuHelper.rotate(:bit8, :right)
{0x40, false}
iex> 0x80 |> Sneex.CpuHelper.rotate(:bit16, :right)
{0x40, false}
iex> 0xFF |> Sneex.CpuHelper.rotate(:bit8, :right)
{0x7F, true}
iex> 0xFF |> Sneex.CpuHelper.rotate(:bit16, :right)
{0x7F, true}
iex> 0x7FFF |> Sneex.CpuHelper.rotate(:bit16, :right)
{0x3FFF, true}
iex> 0x8000 |> Sneex.CpuHelper.rotate(:bit16, :right)
{0x4000, false}
iex> 0xFFFF |> Sneex.CpuHelper.rotate(:bit16, :right)
{0x7FFF, true}
"
@spec rotate(integer(), Sneex.Cpu.bit_size(), :left | :right) :: {integer(), boolean()}
def rotate(value, bitness, :left) do
mask = bitness |> rotate_left_mask()
negative? = value |> check_negative_flag(bitness)
new_value = value |> bsl(1) |> band(mask)
{new_value, negative?}
end
def rotate(value, _bitness, :right) do
mask = 0x0001
is_zero? = value |> band(mask) |> check_zero_flag()
new_value = value |> bsr(1)
{new_value, not is_zero?}
end
defp rotate_left_mask(:bit8), do: 0xFF
defp rotate_left_mask(:bit16), do: 0xFFFF
end
|
lib/sneex/cpu_helper.ex
| 0.876641 | 0.531331 |
cpu_helper.ex
|
starcoder
|
defmodule ExOwm do
require Logger
@moduledoc """
ExOwm, OpenWeatherMap API Elixir client.
This module contains main public interface of the application.
"""
@typedoc """
Current weather data API request.
"""
@type request ::
%{city: String.t()}
| %{city: String.t(), country_code: String.t()}
| %{id: integer()}
| %{lat: float(), lon: float()}
| %{lat: float(), lon: float(), dt: integer()}
| %{zip: String.t(), country_code: String.t()}
@typedoc """
Current weather data API requests.
"""
@type requests :: [request]
@typedoc """
Current weather data API call options corresponding to OWM APIs described in
official docs: http://openweathermap.org/api
The output of the request can be specified according to below options.
"""
@type option :: :format | :units | :lang | :cnt | :like | :accurate | :mode | :cnt
@typedoc """
Keyword list of options.
"""
@type options :: [option: term]
@doc """
Gets weather data of the given location with specified options.
## Examples
iex> ExOwm.get_current_weather([%{city: "Warsaw"}, %{city: "London", country_code: "uk"}], units: :metric, lang: :pl)
"""
@spec get_current_weather(requests, options) :: map
def get_current_weather(loc, opts \\ [])
def get_current_weather(locations, opts) when is_list(locations),
do: ExOwm.CurrentWeather.Coordinator.get_weather(locations, opts)
def get_current_weather(location, opts) when is_map(location),
do: get_current_weather([location], opts)
@doc """
Gets weather data of the given location with specified options.
## Examples
iex> ExOwm.get_weather([%{lat: 52.374031, lon: 4.88969}], units: :metric, lang: :pl)
"""
@spec get_weather(requests, options) :: map
def get_weather(loc, opts \\ [])
def get_weather(locations, opts) when is_list(locations),
do: ExOwm.Weather.Coordinator.get_weather(locations, opts)
def get_weather(location, opts) when is_map(location),
do: get_weather([location], opts)
@doc """
Gets 5 day forecast data of the given location with specified options.
## Examples
iex> ExOwm.get_five_day_forecast([%{city: "Warsaw"}, %{city: "London", country_code: "uk"}], units: :metric, lang: :pl)
"""
@spec get_five_day_forecast(requests, options) :: map
def get_five_day_forecast(locations, opts \\ [])
def get_five_day_forecast(locations, opts) when is_list(locations),
do: ExOwm.FiveDayForecast.Coordinator.get_weather(locations, opts)
def get_five_day_forecast(location, opts) when is_map(location),
do: get_five_day_forecast([location], opts)
@doc """
Gets 1 to 16 days forecast data of the given location with specified options.
## Examples
iex> ExOwm.get_sixteen_day_forecast([%{city: "Warsaw"}, %{city: "London", country_code: "uk"}], units: :metric, lang: :pl, cnt: 16)
"""
@spec get_sixteen_day_forecast(requests, options) :: map
def get_sixteen_day_forecast(locations, opts \\ [])
def get_sixteen_day_forecast(locations, opts) when is_list(locations),
do: ExOwm.SixteenDayForecast.Coordinator.get_weather(locations, opts)
def get_sixteen_day_forecast(location, opts) when is_map(location),
do: get_sixteen_day_forecast([location], opts)
@doc """
Gets historical weather data of the given location with specified options.
dt should be within the last 5 days.
## Examples
iex> ExOwm.get_historical_weather([%{lat: 52.374031, lon: 4.88969, dt: 1615546800}], units: :metric, lang: :pl)
"""
@spec get_historical_weather(requests, options) :: map
def get_historical_weather(loc, opts \\ [])
def get_historical_weather(locations, opts) when is_list(locations),
do: ExOwm.HistoricalWeather.Coordinator.get_weather(locations, opts)
def get_historical_weather(location, opts) when is_map(location),
do: get_historical_weather([location], opts)
end
|
lib/ex_owm.ex
| 0.890945 | 0.466785 |
ex_owm.ex
|
starcoder
|
defmodule RayTracer.Canvas do
@moduledoc """
This module defines methods for drawing pixels
"""
alias RayTracer.Color
alias RayTracer.Matrix
@type t :: %__MODULE__{
width: integer,
height: integer,
pixels: Matrix.matrix
}
@ppm_magic_number "P3"
@ppm_max_color_value 255
@ppm_max_line_length 70
defstruct width: 0, height: 0, pixels: %{}
@spec new(integer, integer, Color.t) :: t
def new(width, height, color \\ Color.new(0, 0, 0)) do
pixels = Matrix.new(height, width, color)
%__MODULE__{width: width, height: height, pixels: pixels}
end
@spec pixel_at(t, integer, integer) :: Color.t
def pixel_at(canvas, x, y), do: Matrix.elem(canvas.pixels, y, x)
@spec write_pixel(t, integer, integer, Color.t) :: t
def write_pixel(canvas = %__MODULE__{width: w, height: h, pixels: p}, x, y, color) do
if x < 0 || x >= canvas.width || y < 0 || y >= canvas.height do
raise ArgumentError, message: "Position out of bounds: #{x}, #{y}. Size is #{w},#{h}."
end
new_pixels = p |> Matrix.set(y, x, color)
%__MODULE__{canvas | pixels: new_pixels}
end
@spec export_to_ppm_file(t, String.t) :: :error | :ok
def export_to_ppm_file(canvas, filename \\ "canvas.ppm") do
case File.write(filename, canvas |> to_ppm) do
:ok -> :ok
_ -> :error
end
end
@spec to_ppm(t) :: String.t
def to_ppm(%RayTracer.Canvas{width: width, height: height, pixels: pixels}) do
pd =
pixels
|> Enum.map(&row_to_ppm/1)
|> Enum.join("\n")
"#{@ppm_magic_number}\n#{width} #{height}\n#{@ppm_max_color_value}\n#{pd}\n"
end
@spec row_to_ppm(Matrix.row) :: String.t
defp row_to_ppm(row) do
row
|> Enum.map(&color_to_ppm/1)
|> Enum.join(" ")
# |> break_ppm_line
end
@spec break_ppm_line(String.t) :: String.t
defp break_ppm_line(row_string, break_at \\ @ppm_max_line_length) do
case String.at(row_string, break_at) do
" " ->
row_string
|> String.split_at(break_at)
|> Tuple.to_list
|> Enum.map(&String.trim/1)
|> Enum.reject(fn(x) -> x |> String.length == 0 end)
|> Enum.map(&break_ppm_line/1)
|> Enum.join("\n")
nil -> row_string
_ -> break_ppm_line(row_string, break_at - 1)
end
end
@spec color_to_ppm(Color.t) :: String.t
defp color_to_ppm(color) do
color
|> Color.scale(@ppm_max_color_value)
|> Color.map(fn (v) -> v |> round() |> to_string() end)
|> Enum.join(" ")
end
end
|
lib/canvas.ex
| 0.878158 | 0.512449 |
canvas.ex
|
starcoder
|
defmodule Ash.DataLayer do
@moduledoc """
The interface for being an ash data layer.
This is a large behaviour, and this capability is not complete, but the idea
is to have a large amount of optional callbacks, and use the `can?/2` callback
to ensure that the engine only ever tries to interact with the data layer in ways
that it supports.
"""
alias Ash.Dsl.Extension
@type t :: module
@type data_layer_query() :: struct
@type feature() ::
:transact
| :multitenant
| {:lateral_join, Ash.Resource.t()}
| {:join, Ash.Resource.t()}
| {:aggregate, Ash.Query.Aggregate.kind()}
| {:query_aggregate, Ash.Query.Aggregate.kind()}
| :aggregate_filter
| :aggregate_sort
| :boolean_filter
| :async_engine
| :create
| :read
| :update
| :destroy
| :limit
| :offset
| :transact
| :filter
| {:filter_expr, struct}
| :sort
| {:sort, Ash.Type.t()}
| :upsert
| :composite_primary_key
@callback functions(Ash.Resource.t()) :: [module]
@callback operators(Ash.Resource.t()) :: [module]
@callback filter(data_layer_query(), Ash.Filter.t(), resource :: Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
@callback sort(data_layer_query(), Ash.Sort.t(), resource :: Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
@callback distinct(data_layer_query(), list(atom), resource :: Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
@callback limit(
data_layer_query(),
limit :: non_neg_integer(),
resource :: Ash.Resource.t()
) ::
{:ok, data_layer_query()} | {:error, term}
@callback offset(
data_layer_query(),
offset :: non_neg_integer(),
resource :: Ash.Resource.t()
) :: {:ok, data_layer_query()} | {:error, term}
@callback set_tenant(Ash.Resource.t(), data_layer_query(), term) ::
{:ok, data_layer_query()} | {:error, term}
@callback resource_to_query(Ash.Resource.t(), Ash.Api.t()) :: data_layer_query()
@callback transform_query(Ash.Query.t()) :: Ash.Query.t()
@callback run_query(data_layer_query(), Ash.Resource.t()) ::
{:ok, list(Ash.Resource.t())} | {:error, term}
@callback equal?(Ash.DataLayer.t()) :: boolean
@callback run_aggregate_query(
data_layer_query(),
list(Ash.Query.Aggregate.t()),
Ash.Resource.t()
) ::
{:ok, map} | {:error, term}
@callback run_aggregate_query_with_lateral_join(
data_layer_query(),
list(Ash.Query.Aggregate.t()),
[Ash.Resource.record()],
source_resource :: Ash.Resource.t(),
destination_resource :: Ash.Resource.t(),
source :: atom,
destination :: atom
) ::
{:ok, list(Ash.Resource.t())} | {:error, term}
@callback run_query_with_lateral_join(
data_layer_query(),
[Ash.Resource.record()],
source_resource :: Ash.Resource.t(),
destination_resource :: Ash.Resource.t(),
source :: atom,
destination :: atom
) ::
{:ok, list(Ash.Resource.t())} | {:error, term}
@callback create(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.t()} | {:error, term}
@callback upsert(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.t()} | {:error, term}
@callback update(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.t()} | {:error, term}
@callback add_aggregate(
data_layer_query(),
Ash.Query.Aggregate.t(),
Ash.Resource.t()
) ::
{:ok, data_layer_query()} | {:error, term}
@callback destroy(Ash.Resource.t(), Ash.Changeset.t()) :: :ok | {:error, term}
@callback transaction(Ash.Resource.t(), (() -> term)) :: {:ok, term} | {:error, term}
@callback in_transaction?(Ash.Resource.t()) :: boolean
@callback source(Ash.Resource.t()) :: String.t()
@callback rollback(Ash.Resource.t(), term) :: no_return
@callback can?(Ash.Resource.t(), feature()) :: boolean
@callback set_context(Ash.Resource.t(), data_layer_query(), map) ::
{:ok, data_layer_query()} | {:error, term}
@optional_callbacks source: 1,
equal?: 1,
run_query: 2,
distinct: 3,
run_query_with_lateral_join: 6,
create: 2,
update: 2,
set_context: 3,
destroy: 2,
filter: 3,
sort: 3,
limit: 3,
offset: 3,
transaction: 2,
rollback: 2,
upsert: 2,
operators: 1,
functions: 1,
in_transaction?: 1,
add_aggregate: 3,
run_aggregate_query: 3,
run_aggregate_query_with_lateral_join: 7,
transform_query: 1,
set_tenant: 3,
resource_to_query: 2
@doc "The data layer of the resource, or nil if it does not have one"
@spec data_layer(Ash.Resource.t()) :: Ash.DataLayer.t()
def data_layer(resource) do
Extension.get_persisted(resource, :data_layer)
end
@doc "Whether or not the data layer supports a specific feature"
@spec data_layer_can?(Ash.Resource.t(), Ash.DataLayer.feature()) :: boolean
def data_layer_can?(resource, feature) do
data_layer = data_layer(resource)
data_layer && Ash.DataLayer.can?(feature, resource)
end
@doc "Custom functions supported by the data layer of the resource"
@spec data_layer_functions(Ash.Resource.t()) :: map
def data_layer_functions(resource) do
Ash.DataLayer.functions(resource)
end
@doc "Wraps the execution of the function in a transaction with the resource's data_layer"
@spec transaction(Ash.Resource.t(), (() -> term)) :: term
def transaction(resource, func) do
if data_layer_can?(resource, :transact) do
data_layer(resource).transaction(resource, func)
else
func.()
end
end
@doc "Rolls back the current transaction"
@spec rollback(Ash.Resource.t(), term) :: no_return
def rollback(resource, term) do
data_layer(resource).rollback(resource, term)
end
@spec resource_to_query(Ash.Resource.t(), Ash.Api.t()) :: data_layer_query()
def resource_to_query(resource, api) do
data_layer = Ash.DataLayer.data_layer(resource)
if :erlang.function_exported(data_layer, :resource_to_query, 2) do
Ash.DataLayer.data_layer(resource).resource_to_query(resource, api)
else
Ash.DataLayer.data_layer(resource).resource_to_query(resource)
end
end
@spec update(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.record()} | {:error, term}
def update(resource, changeset) do
Ash.DataLayer.data_layer(resource).update(resource, changeset)
end
@spec create(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.record()} | {:error, term}
def create(resource, changeset) do
Ash.DataLayer.data_layer(resource).create(resource, changeset)
end
@spec destroy(Ash.Resource.t(), Ash.Changeset.t()) :: :ok | {:error, term}
def destroy(resource, changeset) do
Ash.DataLayer.data_layer(resource).destroy(resource, changeset)
end
@spec source(Ash.Resource.t()) :: String.t()
def source(resource) do
data_layer = Ash.DataLayer.data_layer(resource)
if :erlang.function_exported(data_layer, :source, 1) do
data_layer.source(resource)
else
""
end
end
@spec set_tenant(Ash.Resource.t(), data_layer_query(), term) ::
{:ok, data_layer_query()} | {:error, term}
def set_tenant(resource, query, term) do
Ash.DataLayer.data_layer(resource).set_tenant(resource, query, term)
end
@spec upsert(Ash.Resource.t(), Ash.Changeset.t()) ::
{:ok, Ash.Resource.record()} | {:error, term}
def upsert(resource, changeset) do
Ash.DataLayer.data_layer(resource).upsert(resource, changeset)
end
@spec set_context(Ash.Resource.t(), data_layer_query(), map) ::
{:ok, data_layer_query()} | {:error, term}
def set_context(resource, query, map) do
data_layer = Ash.DataLayer.data_layer(resource)
if :erlang.function_exported(data_layer, :set_context, 3) do
data_layer.set_context(resource, query, map)
else
{:ok, query}
end
end
@spec filter(data_layer_query(), Ash.Filter.t(), Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def filter(query, nil, _), do: {:ok, query}
def filter(query, filter, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
if data_layer.can?(resource, :filter) do
if data_layer.can?(resource, :boolean_filter) do
data_layer.filter(query, filter, resource)
else
simple_filter = Ash.Filter.to_simple_filter(filter)
data_layer.filter(query, simple_filter, resource)
end
else
{:error, "Data layer does not support filtering"}
end
end
@spec sort(data_layer_query(), Ash.Sort.t(), Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def sort(query, sort, resource) do
if can?(:sort, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.sort(query, sort, resource)
else
{:ok, query}
end
end
@spec distinct(data_layer_query(), list(atom) | nil, Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def distinct(query, distinct, resource) do
if can?(:distinct, resource) && distinct do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.distinct(query, distinct, resource)
else
{:ok, query}
end
end
@spec limit(data_layer_query(), limit :: non_neg_integer, Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def limit(query, nil, _resource), do: {:ok, query}
def limit(query, limit, resource) do
if can?(:limit, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.limit(query, limit, resource)
else
{:ok, query}
end
end
@spec offset(data_layer_query(), offset :: non_neg_integer, Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def offset(query, nil, _resource), do: {:ok, query}
def offset(query, offset, resource) do
if can?(:offset, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.offset(query, offset, resource)
else
{:ok, query}
end
end
@spec add_aggregate(data_layer_query(), Ash.Query.Aggregate.t(), Ash.Resource.t()) ::
{:ok, data_layer_query()} | {:error, term}
def add_aggregate(query, aggregate, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.add_aggregate(query, aggregate, resource)
end
@spec can?(feature, Ash.Resource.t()) :: boolean
def can?(feature, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.can?(resource, feature)
end
@spec run_aggregate_query(
data_layer_query(),
list(Ash.Query.Aggregate.t()),
Ash.Resource.t()
) ::
{:ok, map} | {:error, term}
def run_aggregate_query(query, aggregates, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
if :erlang.function_exported(data_layer, :run_aggregate_query, 3) do
data_layer.run_aggregate_query(query, aggregates, resource)
else
{:error, "Aggregate queries not supported"}
end
end
@spec run_query(data_layer_query(), central_resource :: Ash.Resource.t()) ::
{:ok, list(Ash.Resource.record())} | {:error, term}
def run_query(query, central_resource) do
Ash.DataLayer.data_layer(central_resource).run_query(query, central_resource)
end
def run_aggregate_query_with_lateral_join(
query,
aggregates,
root_data,
source_resource,
destination_resource,
source,
destination
) do
Ash.DataLayer.data_layer(source_resource).run_query_with_lateral_join(
query,
aggregates,
root_data,
source_resource,
destination_resource,
source,
destination
)
end
def run_query_with_lateral_join(
query,
root_data,
source_resource,
destination_resource,
source,
destination
) do
Ash.DataLayer.data_layer(source_resource).run_query_with_lateral_join(
query,
root_data,
source_resource,
destination_resource,
source,
destination
)
end
def transact(resource, func) do
if can?(:transact, resource) && not in_transaction?(resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.transaction(resource, func)
else
{:ok, func.()}
end
end
def in_transaction?(resource) do
if can?(:transact, resource) do
data_layer = Ash.DataLayer.data_layer(resource)
data_layer.in_transaction?(resource)
else
false
end
end
def functions(resource) do
data_layer = Ash.DataLayer.data_layer(resource)
if :erlang.function_exported(data_layer, :functions, 1) do
data_layer.functions(resource)
else
%{}
end
end
def transform_query(query) do
data_layer = Ash.DataLayer.data_layer(query.resource)
if :erlang.function_exported(data_layer, :transform_query, 1) do
data_layer.transform_query(query)
else
query
end
end
end
|
lib/ash/data_layer/data_layer.ex
| 0.860486 | 0.513668 |
data_layer.ex
|
starcoder
|
defmodule OffBroadway.Kafka do
@moduledoc ~S"""
Defines a macro to easily define a Kafka Broadway pipeline in your
application, configuring Broadway and Kafka via callbacks.
It starts a Broadway pipeline for each topic and partition for increased
concurrency processing events, receiving partition assignments from the group
coordinator and starting an Elsa group supervisor for each.
It uses the following callbacks:
1. `c:kafka_config/1` receives `start_link` options and
returns the Kafka consumer configuration which is passed to
`Elsa.Supervisor.start_link/1`.
2. `c:broadway_config/3` receives a keyword list of configuration
options, a topic and a partition. It returns the keyword
list to configure the Broadway processors, batchers and contexts.
Called by `OffBroadway.Kafka.ShowtimeHandler`.
For example:
```elixir
defmodule ShowtimeBroadway do
use OffBroadway.Kafka
def kafka_config(_opts) do
[
connection: :per_partition,
endpoints: [localhost: 9092],
group_consumer: [
group: "per_partition",
topics: ["topic1"],
config: [
prefetch_count: 5,
prefetch_bytes: 0,
begin_offset: :earliest
]
]
]
end
def broadway_config(opts, topic, partition) do
[
name: :"broadway_per_partition_#{topic}_#{partition}",
processors: [
default: [
concurrency: 5
]
],
context: %{
pid: Keyword.get(opts, :pid)
}
]
end
def handle_message(processor, message, context) do
send(context.pid, {:message, message})
message
end
end
```
"""
@callback broadway_config(keyword(), String.t(), non_neg_integer()) :: keyword()
@callback kafka_config(term()) :: keyword()
@doc """
Macro which starts pipeline for each Elsa consumer group manager instantiated.
"""
defmacro __using__(_opts) do
quote do
use Broadway
@behaviour OffBroadway.Kafka
def start_link(opts) do
kafka_config = kafka_config(opts)
new_group_consumer =
Keyword.fetch!(kafka_config, :group_consumer)
|> Keyword.put(:handler, OffBroadway.Kafka.ShowtimeHandler)
|> Keyword.put(:handler_init_args, broadway_module: __MODULE__, opts: opts)
config = Keyword.put(kafka_config, :group_consumer, new_group_consumer)
Elsa.Supervisor.start_link(config)
end
end
end
end
|
lib/off_broadway/kafka.ex
| 0.847621 | 0.836688 |
kafka.ex
|
starcoder
|
defmodule XGPS.Ports do
use Supervisor
@doc """
Open one port to be consumed. Needs to have one GPS attached to the port to work.
To simulate, give port_name = :simulate
"""
def start_port(port_name) do
Supervisor.start_child(__MODULE__, [{port_name}])
end
def start_simulator(file_name) do
Supervisor.start_child(__MODULE__, [{:simulate, file_name}])
end
def stop_simulator() do
stop_port(:simulate)
end
def stop_port(port_name_to_stop) do
children =
Supervisor.which_children(__MODULE__)
|> Enum.map(fn({_, pid, :supervisor, _}) -> pid end)
|> Enum.map(fn(pid) -> {pid, XGPS.Port.Supervisor.get_port_name(pid)} end)
|> Enum.filter(fn({_pid, port_name}) -> port_name == port_name_to_stop end)
|> Enum.map(fn({pid, _port_name}) -> pid end)
case length(children) do
0 -> {:ok, :no_port_running}
1 ->
pid = Enum.at(children, 0)
:ok = Supervisor.stop(pid)
end
end
@doc """
Return all the connected port names
"""
def get_running_port_names do
Supervisor.which_children(__MODULE__)
|> Enum.map(fn({_, pid, :supervisor, _}) -> pid end)
|> Enum.map(fn(pid) -> XGPS.Port.Supervisor.get_port_name(pid) end)
end
@doc """
Return the latest position if atteched to GPS.
"""
def get_one_position do
children = Supervisor.which_children(__MODULE__)
case length(children) do
0 -> {:error, :no_port_running}
_ ->
{_, pid, :supervisor, _} = Enum.at(children, 0)
gps_data = XGPS.Port.Supervisor.get_gps_data(pid)
{:ok, gps_data}
end
end
@doc """
Will send one GPS report as the give position.
Since this will effectively generate both RMC and GGA sentences, the broadcaster will produce two values
"""
def send_simulated_position(lat, lon, alt) when is_float(lat) and is_float(lon) and is_float(alt) do
now = DateTime.utc_now()
send_simulated_position(lat, lon, alt, now)
end
@doc """
Will send one GPS report as the give position.
Since this will effectively generate both RMC and GGA sentences, the broadcaster will produce two values
"""
def send_simulated_position(lat, lon, alt, date_time) when is_float(lat) and is_float(lon) and is_float(alt) do
simulators = get_running_simulators()
case length(simulators) do
0 -> {:error, :no_simulator_running}
_ ->
{sim_pid, :simulate} = Enum.at(simulators, 0)
XGPS.Port.Supervisor.send_simulated_position(sim_pid, lat, lon, alt, date_time)
:ok
end
end
def reset_simulated_port_state() do
simulators = get_running_simulators()
case length(simulators) do
0 -> {:error, :no_simulator_running}
_ ->
{sim_pid, :simulate} = Enum.at(simulators, 0)
XGPS.Port.Supervisor.reset_simulated_port_state(sim_pid)
:ok
end
end
@doc """
Will send one GPS report as no fix.
Since this will effectively generate both RMC and GGA sentences, the broadcaster will produce two values
"""
def send_simulated_no_fix() do
now = DateTime.utc_now()
send_simulated_no_fix(now)
end
def send_simulated_no_fix(date_time) do
simulators = get_running_simulators()
case length(simulators) do
0 -> {:error, :no_simulator_running}
_ ->
{sim_pid, :simulate} = Enum.at(simulators, 0)
XGPS.Port.Supervisor.send_simulated_no_fix(sim_pid, date_time)
:ok
end
end
def start_link do
result = {:ok, pid} = Supervisor.start_link(__MODULE__, :ok, name: __MODULE__)
start_port_if_defined_in_config(pid)
result
end
defp start_port_if_defined_in_config(pid) do
case Application.get_env(:xgps, :port_to_start) do
nil ->
:ok
portname_with_args ->
Supervisor.start_child(pid, [portname_with_args])
end
end
# Callbacks
def init(:ok) do
children = [
supervisor(XGPS.Port.Supervisor, [], restart: :transient)
]
supervise(children, strategy: :simple_one_for_one)
end
defp get_running_simulators do
Supervisor.which_children(__MODULE__)
|> Enum.map(fn({_, pid, :supervisor, _}) -> pid end)
|> Enum.map(fn(pid) -> {pid, XGPS.Port.Supervisor.get_port_name(pid)} end)
|> Enum.filter(fn({_pid, port_name}) -> port_name == :simulate end)
end
end
|
lib/xgps/ports.ex
| 0.62395 | 0.469399 |
ports.ex
|
starcoder
|
defmodule PlugSessionMnesia do
@moduledoc """
An application for storing and managing Plug sessions with Mnesia.
This application provides a `Plug.Session.Store` using Mnesia as back-end, and
a session cleaner for automatically deleting inactive sessions. It also
provide helpers for creating the Mnesia table.
Using Mnesia enables session persistence between application reboots and
distribution. However, distribution is not yet supported out of the box by the
table creation helpers. You must create the Mnesia table yourself to use this
feature.
## Setup
To use it in your app, add this to your dependencies:
{:plug_session_mnesia, "~> #{Mix.Project.config()[:version]}"}
Then, add to your configuration:
config :plug_session_mnesia,
table: :session,
max_age: 86_400
It will store the sessions in a Mnesia table named `session` and discard them
if they are inactive for more than 1 day. You can also choose to discard
sessions after a given amount of time, regardless they have been active or
not. To do this, simply add `timestamp: :fixed` to the configuration.
By default, `PlugSessionMnesia.Cleaner` checks every minute for outdated
sessions. You can change this behaviour by setting the `:cleaner_timeout` key
in the configuration with a value in seconds.
You must also tell `Plug.Session` that you use this store:
plug Plug.Session,
key: "_app_key",
store: PlugSessionMnesia.Store
You can then create the Mnesia table:
$ mix session.setup
If you want to use a node name or a custom directory for the Mnesia database,
you can take a look at `Mix.Tasks.Session.Setup`.
You can also create it directly from Elixir using
`PlugSessionMnesia.Helpers.setup!/0`. This can be useful to include in a setup
task to be run in a release environment.
"""
use Application
alias PlugSessionMnesia.Cleaner
@impl true
def start(_type, _args) do
Supervisor.start_link(
[Cleaner],
strategy: :one_for_one,
name: PlugSessionMnesia.Supervisor
)
end
end
|
lib/plug_session_mnesia.ex
| 0.78968 | 0.418697 |
plug_session_mnesia.ex
|
starcoder
|
defmodule Modbux.Rtu.Slave do
@moduledoc """
API for a Modbus RTU Slave device.
"""
use GenServer, restart: :transient
alias Modbux.Model.Shared
alias Modbux.Rtu.{Slave, Framer}
alias Modbux.Rtu
alias Circuits.UART
require Logger
@timeout 1000
@speed 115_200
defstruct model_pid: nil,
uart_pid: nil,
tty: nil,
uart_opts: nil,
parent_pid: nil
@doc """
Starts a Modbus RTU Slave process.
The following options are available:
* `tty` - defines the serial port to spawn the Slave.
* `gen_opts` - defines extra options for the Genserver OTP configuration.
* `uart_opts` - defines extra options for the UART configuration (defaults:
[speed: 115200, rx_framing_timeout: 1000]).
* `model` - defines the DB initial state.
* `active` - (`true` or `false`) enable/disable DB updates notifications (mailbox).
The messages (when active mode is true) have the following form:
`{:modbus_rtu, {:slave_request, payload}}`
or
`{:modbus_rtu, {:slave_error, payload, reason}}`
The following are some reasons:
* `:ecrc` - corrupted message (invalid crc).
* `:einval` - invalid function.
* `:eaddr` - invalid memory address requested.
## Model (DB)
The model or data base (DB) defines the slave memory map, the DB is defined by the following syntax:
```elixir
%{slave_id => %{{memory_type, address_number} => value}}
```
where:
* `slave_id` - specifies a unique unit address from 1 to 247.
* `memory_type` - specifies the memory between:
* `:c` - Discrete Output Coils.
* `:i` - Discrete Input Contacts.
* `:ir` - Analog Input Registers.
* `:hr` - Analog Output Registers.
* `address_number` - specifies the memory address.
* `value` - the current value from that memory.
## Example
```elixir
model = %{80 => %{{:c, 20818} => 0, {:hr, 20818} => 0}}
Modbux.Tcp.Server.start_link(model: model, port: 2000)
```
"""
@spec start_link(keyword) :: :ignore | {:error, any} | {:ok, pid}
def start_link(params) do
gen_opts = Keyword.get(params, :gen_opts, [])
GenServer.start_link(__MODULE__, {params, self()}, gen_opts)
end
@spec stop(atom | pid | {atom, any} | {:via, atom, any}) :: :ok
def stop(pid) do
GenServer.stop(pid)
end
@doc """
Gets the Slave state.
"""
@spec state(atom | pid | {atom, any} | {:via, atom, any}) :: any
def state(pid) do
GenServer.call(pid, :state)
end
@doc """
Updates the state of the Slave DB.
`cmd` is a 4 elements tuple, as follows:
- `{:rc, slave, address, count}` read `count` coils.
- `{:ri, slave, address, count}` read `count` inputs.
- `{:rhr, slave, address, count}` read `count` holding registers.
- `{:rir, slave, address, count}` read `count` input registers.
- `{:fc, slave, address, value}` force single coil.
- `{:phr, slave, address, value}` preset single holding register.
- `{:fc, slave, address, values}` force multiple coils.
- `{:phr, slave, address, values}` preset multiple holding registers.
"""
@spec request(atom | pid | {atom, any} | {:via, atom, any}, any) :: any
def request(pid, cmd) do
GenServer.call(pid, {:request, cmd})
end
@doc """
Gets the current state of the Slave DB.
"""
@spec get_db(atom | pid | {atom, any} | {:via, atom, any}) :: any
def get_db(pid) do
GenServer.call(pid, :get_db)
end
@doc """
Send a raw frame through the serial port.
"""
@spec raw_write(atom | pid | {atom, any} | {:via, atom, any}, any) :: any
def raw_write(pid, data) do
GenServer.call(pid, {:raw_write, data})
end
def init({params, parent_pid}) do
parent_pid = if Keyword.get(params, :active, false), do: parent_pid
tty = Keyword.fetch!(params, :tty)
model = Keyword.fetch!(params, :model)
Logger.debug("(#{__MODULE__}) Starting Modbux Slave at \"#{tty}\"")
uart_opts = Keyword.get(params, :uart_opts, speed: @speed, rx_framing_timeout: @timeout)
{:ok, model_pid} = Shared.start_link(model: model)
{:ok, u_pid} = UART.start_link()
UART.open(u_pid, tty, [framing: {Framer, behavior: :slave}] ++ uart_opts)
state = %Slave{
model_pid: model_pid,
parent_pid: parent_pid,
tty: tty,
uart_pid: u_pid,
uart_opts: uart_opts
}
{:ok, state}
end
def terminate(:normal, _state), do: nil
def terminate(reason, state) do
Logger.error("(#{__MODULE__}) Error: #{inspect(reason)}, state: #{inspect(state)}")
end
def handle_call(:state, _from, state), do: {:reply, state, state}
def handle_call({:request, cmd}, _from, state) do
res =
case Shared.apply(state.model_pid, cmd) do
{:ok, values} ->
Logger.debug("(#{__MODULE__}) DB request: #{inspect(cmd)}, #{inspect(values)}")
values
nil ->
Logger.debug("(#{__MODULE__}) DB update: #{inspect(cmd)}")
error ->
Logger.debug("(#{__MODULE__}) An error has occur #{inspect(error)}")
error
end
{:reply, res, state}
end
def handle_call(:get_db, _from, state) do
{:reply, Shared.state(state.model_pid), state}
end
def handle_call({:raw_write, data}, _from, state) do
UART.write(state.uart_pid, data)
{:reply, :ok, state}
end
def handle_info({:circuits_uart, device, {:error, reason, bad_frame}}, state) do
Logger.warn("(#{__MODULE__}) Error with \"#{device}\" received: #{bad_frame}, reason: #{reason}")
case reason do
:einval ->
if valid_slave_id?(state, bad_frame) do
response = Rtu.pack_res(bad_frame, :einval)
Logger.debug("(#{__MODULE__}) Sending error code: #{inspect(response)}, reason: #{reason}")
UART.write(state.uart_pid, response)
end
_ ->
nil
end
if !is_nil(state.parent_pid), do: notify(state.parent_pid, reason, bad_frame)
{:noreply, state}
end
def handle_info({:circuits_uart, _device, {:partial, data}}, state) do
Logger.warn("(#{__MODULE__}) Timeout: #{inspect(data)}")
{:noreply, state}
end
def handle_info({:circuits_uart, device, modbus_frame}, state) do
Logger.debug("(#{__MODULE__}) Recieved from UART (#{device}): #{inspect(modbus_frame)}")
cmd = Rtu.parse_req(modbus_frame)
Logger.debug("(#{__MODULE__}) Received Modbux request: #{inspect(cmd)}")
case Shared.apply(state.model_pid, cmd) do
{:ok, values} ->
response = Rtu.pack_res(cmd, values)
if !is_nil(state.parent_pid), do: notify(state.parent_pid, nil, cmd)
UART.write(state.uart_pid, response)
{:error, reason} ->
response = Rtu.pack_res(modbus_frame, reason)
if !is_nil(state.parent_pid), do: notify(state.parent_pid, reason, cmd)
UART.write(state.uart_pid, response)
Logger.debug(
"(#{__MODULE__}) An error has occur for cmd: #{inspect(cmd)}, response #{inspect(response)}"
)
nil ->
nil
end
{:noreply, state}
end
# Catch all clause
def handle_info(msg, state) do
Logger.warn("(#{__MODULE__}) Unknown msg: #{inspect(msg)}")
{:noreply, state}
end
defp valid_slave_id?(state, <<slave_id, _b_tail::binary>>) do
state.model_pid
|> Shared.state()
|> Map.has_key?(slave_id)
end
defp notify(pid, nil, cmd) do
send(pid, {:modbus_rtu, {:slave_request, cmd}})
end
defp notify(pid, reason, cmd) do
send(pid, {:modbus_rtu, {:slave_error, cmd, reason}})
end
end
|
lib/rtu/slave.ex
| 0.893527 | 0.758085 |
slave.ex
|
starcoder
|
defmodule Desktop.Menu do
@moduledoc """
Menu module used to create and handle menus in Desktop
Menues are defined similiar to Live View using a callback module an XML:
```
defmodule ExampleMenuBar do
use Desktop.Menu
@impl true
def mount(menu) do
menu = assign(menu, items: ExampleRepo.all_items())
{:ok, menu}
end
@impl true
def handle_event(command, menu) do
case command do
<<"open">> -> :not_implemented
<<"quit">> -> Desktop.Window.quit()
<<"help">> -> :wx_misc.launchDefaultBrowser(\'https://google.com\')
<<"about">> -> :not_implemented
end
{:noreply, menu}
end
@impl true
def render(assigns) do
~E\"""
<menubar>
<menu label="<%= gettext "File" %>">
<item onclick="open"><%= gettext "Open" %></item>
<hr/>
<item onclick="quit"><%= gettext "Quit" %></item>
</menu>
<menu label="<%= gettext "Items" %>">
<%= for item <- @items do %>
<item><%= item.name %></item>
<% end %>
</menu>
<menu label="<%= gettext "Help" %>">
<item onclick="help"><%= gettext "Show Documentation" %></item>
<item onclick="about"><%= gettext "About" %></item>
</menu>
</menubar>
\"""
end
end
```
# Template
As in live view the template can either be embedded in the `def render(assigns)`
method or it can be side loaded as a .eex file next to the menues .ex file.
# XML Structure
These items are defined:
## `<menubar>...menues...</menubar>`
For an application (window) menubar this must be the root element. When
passing a menubar to `Desktop.Window` start parameters this has to be the root element.
It has no attributes
## `<menu label="Label">...items...</menu>`
For an icon menu `menu` must be the root element. Menu elements can contain multiple
children of type `menu`, `item` and `hr`
### Attributes
* `label` - the label that should be displayed on the menu
## `<item ...>Label</item>`
This is an entry in the menu with a text a type and an onclick action
### Attributes
* `onclick` - an event name that should be fired when this item is clicked. It will cause `handle_event/2` to be called
* `type` - the type of the item. The default is `normal`, but it can be either
* `normal` - a normal text item
* `radio` - a radio button
* `checkbox` - a checkbox item
* `checked` - whether the `checkbox` or `radio` button should be checked. `nil`, `false` and `0` are treated
as false values, every other value is treated as true.
* `disabled` - whether the item should be disabled. `nil`, `false` and `0` are treated
as false values, every other value is treated as true.
## `<hr />`
A separator item
"""
use GenServer
require Logger
alias Desktop.Menu
alias Desktop.Menu.{Adapter, Parser}
defstruct [
:__adapter__,
:app,
:assigns,
:module,
:dom,
:pid,
:last_render
]
@type t() :: %Menu{
__adapter__: any(),
app: nil,
assigns: %{},
module: module,
dom: any(),
pid: nil | pid(),
last_render: nil | DateTime.t()
}
@callback mount(assigns :: map()) :: {:ok, map()}
@callback handle_event(event_name :: String.t(), assigns :: map()) :: {:noreply, map()}
@callback handle_info(any(), assigns :: map()) :: {:noreply, map()}
@callback render(Keyword.t()) :: String.t()
@doc false
defmacro __using__(opts) do
Module.register_attribute(__CALLER__.module, :is_menu_server, persist: true, accumulate: false)
Module.put_attribute(__CALLER__.module, :is_menu_server, Keyword.get(opts, :server, true))
# Phoenix.LiveView.HTMLEngine vs. Phoenix.HTML.Engine
quote do
@behaviour Desktop.Menu
import Desktop.Menu, only: [assign: 2, connected?: 1]
import Phoenix.HTML, only: [sigil_e: 2, sigil_E: 2]
import Phoenix.LiveView.Helpers, only: [sigil_L: 2, sigil_H: 2]
alias Desktop.Menu
@before_compile Desktop.Menu
end
end
defmacro __before_compile__(env) do
render? = Module.defines?(env.module, {:render, 1})
root = Path.dirname(env.file)
filename = template_filename(env)
templates = Phoenix.Template.find_all(root, filename)
case {render?, templates} do
{true, [template | _]} ->
IO.warn(
"ignoring template #{inspect(template)} because the Menu " <>
"#{inspect(env.module)} defines a render/1 function",
Macro.Env.stacktrace(env)
)
:ok
{true, []} ->
:ok
{false, [template]} ->
ext = template |> Path.extname() |> String.trim_leading(".") |> String.to_atom()
engine = Map.fetch!(Phoenix.Template.engines(), ext)
ast = engine.compile(template, filename)
quote do
@file unquote(template)
@external_resource unquote(template)
def render(var!(assigns)) when is_map(var!(assigns)) do
unquote(ast)
end
end
{false, [_ | _]} ->
IO.warn(
"multiple templates were found for #{inspect(env.module)}: #{inspect(templates)}",
Macro.Env.stacktrace(env)
)
:ok
{false, []} ->
template = Path.join(root, filename <> ".heex")
message = ~s'''
render/1 was not implemented for #{inspect(env.module)}.
Make sure to either explicitly define a render/1 clause with a Menu template:
def render(assigns) do
~H"""
...
"""
end
Or create a file at #{inspect(template)} with the Menu template.
'''
IO.warn(message, Macro.Env.stacktrace(env))
quote do
@external_resource unquote(template)
def render(_assigns) do
raise unquote(message)
end
end
end
end
defp template_filename(env) do
env.module
|> Module.split()
|> List.last()
|> Macro.underscore()
|> Kernel.<>(".html")
end
def connected?(_menu), do: true
def assign(menu, properties \\ [])
def assign(menu, properties) when is_list(properties) do
assign(menu, Map.new(properties))
end
def assign(menu = %Menu{assigns: assigns}, properties) when is_map(properties) do
%Menu{menu | assigns: Map.merge(assigns, properties)}
end
def assign(menu, property, value) when is_atom(property) do
assign(menu, %{property => value})
end
def assign_new(menu = %Menu{assigns: assigns}, property, fun)
when is_atom(property) and is_function(fun) do
%Menu{menu | assigns: Map.put_new_lazy(assigns, property, fun)}
end
# GenServer implementation
def start!(init_opts \\ [], opts \\ [])
def start!(init_opts, opts) do
case start_link(init_opts, opts) do
{:ok, pid} -> pid
{:error, {:already_started, pid}} -> pid
{:error, reason} -> raise reason
:ignore -> nil
end
end
@spec start_link(keyword(), keyword()) :: GenServer.on_start()
def start_link(init_opts \\ [], opts \\ [])
def start_link(init_opts, opts) do
GenServer.start_link(Menu, init_opts, opts)
end
@impl true
def init(init_opts) do
menu_pid = self()
module = Keyword.get(init_opts, :module)
dom = Keyword.get(init_opts, :dom, [])
app = Keyword.get(init_opts, :app, nil)
adapter_module =
case Keyword.get(init_opts, :adapter, Adapter.Wx) do
mod when mod in [Adapter.Wx, Adapter.DBus] -> mod
_ -> Adapter.Wx
end
adapter_opts =
init_opts
|> Keyword.drop([:dom, :adapter])
|> Keyword.put(:menu_pid, menu_pid)
adapter =
adapter_opts
|> adapter_module.new()
|> Adapter.create(dom)
menu =
%Menu{
__adapter__: adapter,
app: app,
module: module,
dom: dom,
assigns: %{},
pid: menu_pid
}
|> do_mount()
if is_module_server?(module) do
Process.register(menu_pid, module)
end
{:ok, menu}
end
def trigger_event(menu_pid, event) do
GenServer.call(menu_pid, {:trigger_event, event})
end
def popup_menu(menu_pid) do
GenServer.call(menu_pid, :popup_menu)
end
def menubar(menu_pid) do
GenServer.call(menu_pid, :menubar)
end
def get_icon(%Menu{pid: menu_pid}) when is_pid(menu_pid) do
get_icon(menu_pid)
end
def get_icon(menu_pid) when is_pid(menu_pid) do
GenServer.call(menu_pid, :get_icon)
end
def set_icon(%Menu{pid: menu_pid}, icon) when is_pid(menu_pid) do
set_icon(menu_pid, icon)
end
def set_icon(menu_pid, icon) when is_pid(menu_pid) do
if menu_pid == self() do
spawn_link(Menu, :set_icon, [menu_pid, icon])
else
GenServer.call(menu_pid, {:set_icon, icon})
end
end
@impl true
def handle_call(:menubar, _from, menu = %{__adapter__: adapter}) do
{:reply, Adapter.menubar(adapter), menu}
end
@impl true
def handle_call(:get_icon, _from, menu) do
{:reply, get_adapter_icon(menu), menu}
end
@impl true
def handle_call({:set_icon, icon}, _from, menu) do
case set_adapter_icon(menu, icon) do
{:ok, menu} -> {:reply, get_adapter_icon(menu), menu}
error -> {:reply, error, menu}
end
end
@impl true
def handle_call({:trigger_event, event}, _from, menu = %{module: module}) do
menu =
with {:ok, {:noreply, menu}} <- invoke_module_func(module, :handle_event, [event, menu]),
{:ok, _updated?, menu} <- update_dom(menu) do
menu
else
_ -> menu
end
{:reply, menu.assigns, menu}
end
@impl true
def handle_cast(:popup_menu, menu = %{__adapter__: adapter}) do
adapter = Adapter.popup_menu(adapter)
{:noreply, %{menu | __adapter__: adapter}}
end
@impl true
def handle_cast(:recreate_menu, menu = %{__adapter__: adapter, dom: dom}) do
# This is called from within the Adapter
adapter = Adapter.recreate_menu(adapter, dom)
{:noreply, %{menu | __adapter__: adapter}}
end
@impl true
def handle_cast(:mount, menu) do
{:noreply, do_mount(menu)}
end
@impl true
def handle_info(event, menu = %{__adapter__: adapter = %{__struct__: adapter_module}})
when is_tuple(event) and elem(event, 0) == :wx do
{:noreply, adapter} = adapter_module.handle_info(event, adapter)
{:noreply, %{menu | __adapter__: adapter}}
end
@impl true
def handle_info(msg, menu) do
{:noreply, proxy_handle_info(msg, menu)}
end
# Private functions
defp get_adapter_icon(%{__adapter__: adapter}) do
Adapter.get_icon(adapter)
end
defp set_adapter_icon(menu = %{app: app}, {:file, icon}) do
with {:ok, wx_icon} <- Desktop.Image.new_icon(app, icon),
ret = {:ok, _menu} <- set_adapter_icon(menu, wx_icon) do
# Destroy the :wxIcon
Desktop.Image.destroy(wx_icon)
# Now return the result
ret
end
end
defp set_adapter_icon(menu = %{__adapter__: adapter}, icon) do
with {:ok, adapter} <- Adapter.set_icon(adapter, icon) do
menu = %{menu | __adapter__: adapter}
{:ok, menu}
end
end
defp do_mount(menu = %Menu{module: module}) do
case invoke_module_func(module, :mount, [menu]) do
{:ok, {:ok, menu}} ->
case update_dom(menu) do
{:ok, _updated?, menu} -> menu
_error -> menu
end
_ ->
menu
end
end
defp proxy_handle_info(msg, menu = %Menu{module: module}) do
with {:ok, {:noreply, menu}} <- invoke_module_func(module, :handle_info, [msg, menu]),
{:ok, _updated?, menu} <- update_dom(menu) do
menu
else
_ -> menu
end
end
@spec update_dom(menu :: t()) :: {:ok, updated :: boolean(), menu :: t()} | {:error, binary()}
defp update_dom(menu = %Menu{__adapter__: adapter, module: module, dom: dom, assigns: assigns}) do
with {:ok, new_dom} <- invoke_render(module, assigns) do
if new_dom != dom do
adapter = Adapter.update_dom(adapter, new_dom)
{:ok, true, %{menu | __adapter__: adapter, dom: new_dom, last_render: DateTime.utc_now()}}
else
{:ok, false, menu}
end
end
end
@spec invoke_render(module :: module(), assigns :: map()) ::
{:ok, any()} | {:error, binary()}
defp invoke_render(module, assigns) do
with {:ok, str_render} <- invoke_module_func(module, :render, [assigns]) do
{:ok, Parser.parse(str_render)}
end
end
@spec invoke_module_func(module :: module(), func :: atom(), args :: list(any())) ::
{:error, binary()} | {:ok, any()}
defp invoke_module_func(module, func, args) do
try do
Kernel.apply(module, func, args)
rescue
error ->
Logger.error(Exception.format(:error, error, __STACKTRACE__))
{:error, "Failed to invoke #{module}.#{func}/#{Enum.count(args)}"}
else
return -> {:ok, return}
end
end
defp is_module_server?(module) do
try do
case Keyword.get(module.__info__(:attributes), :is_menu_server, false) do
[true] -> true
_ -> false
end
rescue
_error -> false
end
end
end
|
lib/desktop/menu.ex
| 0.694924 | 0.54819 |
menu.ex
|
starcoder
|
defmodule Advent.Day17 do
defmodule Conway3D do
def new(input) do
for {line, y} <- Enum.with_index(String.split(input, "\n", trim: true)),
{char, x} <- Enum.with_index(String.codepoints(line)),
char == "#",
into: MapSet.new(),
do: {x, y, 0}
end
defp active?(actives, {x, y, z}) do
MapSet.member?(actives, {x, y, z})
end
def count_actives(actives), do: Enum.count(actives)
defp count_active_neighbors(actives, {x, y, z}) do
neighbors =
for dx <- -1..1,
dy <- -1..1,
dz <- -1..1,
{dx, dy, dz} != {0, 0, 0},
do: {x + dx, y + dy, z + dz}
Enum.count(neighbors, &active?(actives, &1))
end
defp coordinate_range(actives) do
Enum.reduce(actives, {{0, 0}, {0, 0}, {0, 0}}, fn {x, y, z},
{{min_x, max_x}, {min_y, max_y},
{min_z, max_z}} ->
{
Enum.min_max([min_x, x, max_x]),
Enum.min_max([min_y, y, max_y]),
Enum.min_max([min_z, z, max_z])
}
end)
end
def next_cycle(actives) do
{{min_x, max_x}, {min_y, max_y}, {min_z, max_z}} = coordinate_range(actives)
for x <- (min_x - 1)..(max_x + 1),
y <- (min_y - 1)..(max_y + 1),
z <- (min_z - 1)..(max_z + 1),
reduce: MapSet.new() do
acc ->
coordinate = {x, y, z}
next_active =
case {active?(actives, coordinate), count_active_neighbors(actives, coordinate)} do
{true, neighbors} when neighbors in [2, 3] -> true
{false, 3} -> true
_ -> false
end
if next_active, do: MapSet.put(acc, coordinate), else: acc
end
end
end
def part_1(input) do
Enum.reduce(1..6, Conway3D.new(input), fn _, actives -> Conway3D.next_cycle(actives) end)
|> Conway3D.count_actives()
end
defmodule Conway4D do
def new(input) do
for {line, y} <- Enum.with_index(String.split(input, "\n", trim: true)),
{char, x} <- Enum.with_index(String.codepoints(line)),
char == "#",
into: MapSet.new(),
do: {x, y, 0, 0}
end
defp active?(actives, {x, y, z, w}) do
MapSet.member?(actives, {x, y, z, w})
end
def count_actives(actives), do: Enum.count(actives)
defp count_active_neighbors(actives, {x, y, z, w}) do
neighbors =
for dx <- -1..1,
dy <- -1..1,
dz <- -1..1,
dw <- -1..1,
{dx, dy, dz, dw} != {0, 0, 0, 0},
do: {x + dx, y + dy, z + dz, w + dw}
Enum.count(neighbors, &active?(actives, &1))
end
defp coordinate_range(actives) do
Enum.reduce(actives, {{0, 0}, {0, 0}, {0, 0}, {0, 0}}, fn {x, y, z, w},
{{min_x, max_x}, {min_y, max_y},
{min_z, max_z},
{min_w, max_w}} ->
{
Enum.min_max([min_x, x, max_x]),
Enum.min_max([min_y, y, max_y]),
Enum.min_max([min_z, z, max_z]),
Enum.min_max([min_w, w, max_w])
}
end)
end
def next_cycle(actives) do
{{min_x, max_x}, {min_y, max_y}, {min_z, max_z}, {min_w, max_w}} = coordinate_range(actives)
for x <- (min_x - 1)..(max_x + 1),
y <- (min_y - 1)..(max_y + 1),
z <- (min_z - 1)..(max_z + 1),
w <- (min_w - 1)..(max_w + 1),
reduce: MapSet.new() do
acc ->
coordinate = {x, y, z, w}
next_active =
case {active?(actives, coordinate), count_active_neighbors(actives, coordinate)} do
{true, neighbors} when neighbors in [2, 3] -> true
{false, 3} -> true
_ -> false
end
if next_active, do: MapSet.put(acc, coordinate), else: acc
end
end
end
def part_2(input) do
Enum.reduce(1..6, Conway4D.new(input), fn _, actives -> Conway4D.next_cycle(actives) end)
|> Conway4D.count_actives()
end
end
|
shritesh+elixir/lib/advent/day_17.ex
| 0.550124 | 0.602646 |
day_17.ex
|
starcoder
|
defmodule ExCell.Adapters.CellJS do
@moduledoc """
The CellJS adapter can be used to output the cells as HTML compatible with
[cells-js](https://github.com/DefactoSoftware/cells-js). CellsJS was written
with ExCell in mind.
Tags are automatically closed when they are part of the
[void elements](https://stackoverflow.com/questions/4693939/self-closing-tags-void-elements-in-html5)
specification.
CellsJS uses two predefined attributes to parse the Javascript. First it
will look for the `data-cell` cell attribute and match it to the defined Cell
in Javascript.
Second it will take the JSON arguments set on the `data-cell-params` attribute
and use that to initialize the cell with user defined parameters.
"""
@behaviour ExCell.Adapter
alias Phoenix.HTML
alias Phoenix.HTML.Tag
def void_elements, do: [
"area",
"base",
"br",
"col",
"command",
"embed",
"hr",
"img",
"input",
"keygen",
"link",
"meta",
"param",
"source",
"track",
"wbr"
]
def void_element?(tag) when is_atom(tag), do: void_element?(Atom.to_string(tag))
def void_element?(tag), do: tag in void_elements()
@doc """
The data_attribute function is used to build up the data attributes and set
the default `data-cell` and `data-cell-params` attributes.
"""
def data_attribute(name, id, data \\ [], params \\ %{})
def data_attribute(name, id, nil, params), do: data_attribute(name, id, [], params)
def data_attribute(name, id, data, params),
do:
Keyword.merge(
data,
cell: name,
cell_id: id,
cell_params: Jason.encode!(params)
)
@doc """
The attributes function is used to auto fill the attributes for a container
with the data attributes.
"""
def attributes(name, id, attributes \\ [], params \\ %{}) do
Keyword.put(
attributes,
:data,
data_attribute(name, id, Keyword.get(attributes, :data, []), params)
)
end
@doc """
The container renders HTML with the attributes, class name and data attributes
prefilled. The HTML is rendered with Phoenix.HTML.Tag.
"""
def container(%{
name: name,
attributes: attributes,
params: params,
content: content,
id: id
}) do
{tag, attributes} = Keyword.pop(attributes, :tag, :div)
attributes = attributes(name, id, attributes, params)
case void_element?(tag) do
true -> Tag.tag(tag, attributes)
false -> Tag.content_tag(tag, content, attributes)
end
end
def container(%{id: id} = options, callback) do
options
|> Map.put(:content, callback.(%{element: &(element(id, &1))}))
|> container()
end
def element(id, element) do
HTML.raw(~s(data-cell-parent-id="#{id}" data-cell-element="#{element}"))
end
end
|
lib/ex_cell/adapters/cell_js.ex
| 0.797714 | 0.688468 |
cell_js.ex
|
starcoder
|
defmodule ExthCrypto.Math do
@moduledoc """
Helpers for basic math functions.
"""
@doc """
Simple function to compute modulo function to work on integers of any sign.
## Examples
iex> ExthCrypto.Math.mod(5, 2)
1
iex> ExthCrypto.Math.mod(-5, 1337)
1332
iex> ExthCrypto.Math.mod(1337 + 5, 1337)
5
iex> ExthCrypto.Math.mod(0, 1337)
0
"""
def mod(x, n) when x > 0, do: rem(x, n)
def mod(x, n) when x < 0, do: rem(n + x, n)
def mod(0, _n), do: 0
@doc """
Simple wrapper function to convert a hex string to a binary.
## Examples
iex> ExthCrypto.Math.hex_to_bin("01020a0d")
<<0x01, 0x02, 0x0a, 0x0d>>
"""
@spec hex_to_bin(String.t()) :: binary()
def hex_to_bin(hex) do
{:ok, bin} = Base.decode16(hex, case: :lower)
bin
end
@doc """
Left pads a given binary to specified length in bytes.
This function raises if binary longer than given length already.
## Examples
iex> ExthCrypto.Math.pad(<<1, 2, 3>>, 6)
<<0x00, 0x00, 0x00, 0x01, 0x02, 0x03>>
iex> ExthCrypto.Math.pad(<<1, 2, 3>>, 4)
<<0x00, 0x01, 0x02, 0x03>>
iex> ExthCrypto.Math.pad(<<1, 2, 3>>, 3)
<<0x01, 0x02, 0x03>>
iex> ExthCrypto.Math.pad(<<1, 2, 3>>, 0)
** (ArgumentError) argument error
iex> ExthCrypto.Math.pad(<<>>, 0)
<<>>
"""
@spec pad(binary(), non_neg_integer()) :: binary()
def pad(bin, length) do
padding_bits = (length - byte_size(bin)) * 8
<<0x00::size(padding_bits)>> <> bin
end
@doc """
Simple wrapper function to convert a binary to a hex string.
## Examples
iex> ExthCrypto.Math.bin_to_hex(<<0x01, 0x02, 0x0a, 0x0d>>)
"01020a0d"
"""
@spec bin_to_hex(binary()) :: String.t()
def bin_to_hex(bin), do: Base.encode16(bin, case: :lower)
@doc """
Generate a random nonce value of specified length.
## Examples
iex> ExthCrypto.Math.nonce(32) |> byte_size
32
iex> ExthCrypto.Math.nonce(32) == ExthCrypto.Math.nonce(32)
false
"""
@spec nonce(non_neg_integer()) :: binary()
def nonce(nonce_size) do
:crypto.strong_rand_bytes(nonce_size)
end
@doc """
Computes the xor between two equal length binaries.
## Examples
iex> ExthCrypto.Math.xor(<<0b10101010>>, <<0b11110000>>)
<<0b01011010>>
"""
@spec xor(binary(), binary()) :: binary()
def xor(a, b) when byte_size(a) == byte_size(b) do
:crypto.exor(a, b)
end
end
|
apps/exth_crypto/lib/math/math.ex
| 0.837686 | 0.530541 |
math.ex
|
starcoder
|
defmodule AttributeRepositoryRiak do
@moduledoc """
## Initializing a bucket type for attribute repository
```sh
$ sudo riak-admin bucket-type create attr_rep '{"props":{"datatype":"map", "backend":"leveldb_mult"}}'
attr_rep created
$ sudo riak-admin bucket-type activate attr_rep
attr_rep has been activated
```
## Options
### run options (`run_opts`)
- `:instance`: instance name (an `atom()`)
- `:bucket_type`: a `String.t()` for the bucket type that must be created beforehand
"""
require Logger
alias AttributeRepository.Search.AttributePath
use AttributeRepository.Read
use AttributeRepository.Write
use AttributeRepository.Search
@behaviour AttributeRepository.Install
@behaviour AttributeRepository.Read
@behaviour AttributeRepository.Write
@behaviour AttributeRepository.Search
@impl AttributeRepository.Install
def install(run_opts, _init_opts) do
:ok =
Riak.Search.Schema.create(
schema_name(run_opts),
(:code.priv_dir(:attribute_repository_riak) ++ '/schema.xml') |> File.read!()
)
:ok = Riak.Search.Index.put(index_name(run_opts), schema_name(run_opts))
:ok =
Riak.Search.Index.set(
{run_opts[:bucket_type], bucket_name(run_opts)},
index_name(run_opts)
)
end
@impl AttributeRepository.Read
def get(resource_id, result_attributes, run_opts) do
case Riak.find(run_opts[:bucket_type], bucket_name(run_opts), resource_id) do
nil ->
{:error, AttributeRepository.Read.NotFoundError.exception("Entry not found")}
attribute_list ->
{
:ok,
Enum.reduce(
Riak.CRDT.Map.value(attribute_list),
%{},
fn
{{attribute_name, _attribute_type}, attribute_value}, acc ->
{attribute_name, attribute_type} =
case Regex.run(~r/^(.*)(_integer|_date|_binarydata)?$/U, attribute_name,
capture: :all_but_first
) do
[attribute_name, "_integer"] ->
{attribute_name, :integer}
[attribute_name, "_date"] ->
{attribute_name, :date}
[attribute_name, "_binarydata"] ->
{attribute_name, :binary_data}
[attribute_name] ->
{attribute_name, :string}
end
if result_attributes == :all or attribute_name in result_attributes do
case attribute_type do
:string ->
Map.put(acc, attribute_name, attribute_value)
:date ->
Map.put(
acc,
attribute_name,
elem(DateTime.from_iso8601(attribute_value), 1)
)
:binary_data ->
Map.put(acc, attribute_name, {:binary_data, attribute_value})
:integer ->
{int, _} = Integer.parse(attribute_value)
Map.put(acc, attribute_name, int)
end
else
acc
end
end
)
}
end
end
@impl AttributeRepository.Write
def put(resource_id, resource, run_opts) do
new_base_obj =
case Riak.find(run_opts[:bucket_type], bucket_name(run_opts), resource_id) do
obj when not is_nil(obj) ->
# FIXME: mwe may not need to keep the same object in the case of repacement:
# just deleting it and creating a new could be enough?
# There would be however a short time with no object
Enum.reduce(
Riak.CRDT.Map.keys(obj),
obj,
fn
{key, type}, acc ->
Riak.CRDT.Map.delete(acc, {key, type})
end
)
nil ->
Riak.CRDT.Map.new()
end
riak_res =
Enum.reduce(
resource,
new_base_obj,
fn
{key, value}, acc ->
pre_insert_map_put(acc, key, value)
end
)
case Riak.update(riak_res, run_opts[:bucket_type], bucket_name(run_opts), resource_id) do
:ok ->
{:ok, resource}
_ ->
{:error, AttributeRepository.WriteError.exception("Write error")}
end
end
@impl AttributeRepository.Write
def modify(resource_id, modify_ops, run_opts) do
case Riak.find(run_opts[:bucket_type], bucket_name(run_opts), resource_id) do
obj when not is_nil(obj) ->
modified_obj =
Enum.reduce(
modify_ops,
obj,
fn
{:add, attribute_name, attribute_value}, acc ->
pre_insert_map_put(acc, attribute_name, attribute_value)
{:replace, attribute_name, value}, acc ->
try do
# sets can only be for strings - so no need to handle date, etc. here
Riak.CRDT.Map.update(
acc,
:set,
attribute_name,
fn
set ->
set =
Enum.reduce(
Riak.CRDT.Set.value(set),
set,
fn
val, acc ->
Riak.CRDT.Set.delete(acc, val)
end
)
Riak.CRDT.Set.put(set, value)
end
)
rescue
_ ->
pre_insert_map_put(acc, attribute_name, value)
end
{:replace, attribute_name, old_value, new_value}, acc ->
try do
# sets can only be for strings - so no need to handle date, etc. here
Riak.CRDT.Map.update(
acc,
:set,
attribute_name,
fn
set ->
set
|> Riak.CRDT.Set.delete(old_value)
|> Riak.CRDT.Set.put(new_value)
end
)
rescue
_ ->
pre_insert_map_put(acc, attribute_name, new_value)
end
{:delete, attribute_name}, acc ->
case map_entry_data_type_of_key(obj, attribute_name) do
data_type when not is_nil(data_type) ->
Riak.CRDT.Map.delete(acc, {attribute_name, data_type})
nil ->
acc
end
{:delete, attribute_name, attribute_value}, acc ->
try do
Riak.CRDT.Map.update(
acc,
:set,
attribute_name,
fn
obj ->
Riak.CRDT.Set.delete(obj, attribute_value)
end
)
rescue
_ ->
acc
end
end
)
case Riak.update(
modified_obj,
run_opts[:bucket_type],
bucket_name(run_opts),
resource_id
) do
:ok ->
:ok
_ ->
{:error, AttributeRepository.WriteError.exception("Write error")}
end
nil ->
{:error, AttributeRepository.Read.NotFoundError.exception("Entry not found")}
end
end
defp pre_insert_map_put(map, attribute_name, value) when is_integer(value) do
map
|> crdt_map_delete_if_present(attribute_name)
|> crdt_map_delete_if_present(attribute_name <> "_binarydata")
|> crdt_map_delete_if_present(attribute_name <> "_date")
|> Riak.CRDT.Map.put(attribute_name <> "_integer", to_riak_crdt(value))
end
defp pre_insert_map_put(map, attribute_name, %DateTime{} = value) do
map
|> crdt_map_delete_if_present(attribute_name)
|> crdt_map_delete_if_present(attribute_name <> "_integer")
|> crdt_map_delete_if_present(attribute_name <> "_binarydata")
|> Riak.CRDT.Map.put(attribute_name <> "_date", to_riak_crdt(value))
end
defp pre_insert_map_put(map, attribute_name, {:binary_data, binary_data}) do
map
|> crdt_map_delete_if_present(attribute_name)
|> crdt_map_delete_if_present(attribute_name <> "_integer")
|> crdt_map_delete_if_present(attribute_name <> "_date")
|> Riak.CRDT.Map.put(attribute_name <> "_binarydata", to_riak_crdt(binary_data))
end
defp pre_insert_map_put(map, attribute_name, value) do
map
|> crdt_map_delete_if_present(attribute_name <> "_integer")
|> crdt_map_delete_if_present(attribute_name <> "_binarydata")
|> crdt_map_delete_if_present(attribute_name <> "_date")
|> Riak.CRDT.Map.put(attribute_name, to_riak_crdt(value))
end
defp crdt_map_delete_if_present(map, attribute_name) do
if Riak.CRDT.Map.has_key?(map, attribute_name) do
Riak.CRDT.Map.delete(map, {attribute_name, :register})
else
map
end
end
@impl AttributeRepository.Write
def delete(resource_id, run_opts) do
Riak.delete(run_opts[:bucket_type], bucket_name(run_opts), resource_id)
end
@impl AttributeRepository.Search
def search(filter, attributes, run_opts) do
case Riak.Search.query(index_name(run_opts), build_riak_filter(filter)) do
{:ok, {:search_results, result_list, _, _}} ->
for {_index_name, result_attributes} <- result_list do
{
id_from_search_result(result_attributes),
Enum.reduce(
result_attributes,
%{},
fn {attribute_name, attribute_value}, acc ->
to_search_result_map(acc, attribute_name, attribute_value, attributes)
end
)
}
end
{:error, reason} ->
{:error, AttributeRepository.ReadError.exception(inspect(reason))}
end
rescue
e in AttributeRepository.UnsupportedError ->
{:error, e}
end
defp id_from_search_result(result_attributes) do
:proplists.get_value("_yz_id", result_attributes)
|> String.split("*")
|> Enum.at(3)
end
defp to_search_result_map(result_map, attribute_name, attribute_value, attribute_list) do
res =
Regex.run(
~r/(.*)_(register|flag|counter|set|integer_register|date_register|binarydata_register)/U,
attribute_name,
capture: :all_but_first
)
if res != nil and (attribute_list == :all or List.first(res) in attribute_list) do
case res do
[attribute_name, "register"] ->
Map.put(result_map, attribute_name, attribute_value)
[attribute_name, "flag"] ->
Map.put(result_map, attribute_name, attribute_value == "true")
[attribute_name, "counter"] ->
{int, _} = Integer.parse(attribute_value)
Map.put(result_map, attribute_name, int)
[attribute_name, "set"] ->
Map.put(
result_map,
attribute_name,
[attribute_value] ++ (result_map[attribute_name] || [])
)
[attribute_name, "integer_register"] ->
{int, _} = Integer.parse(attribute_value)
Map.put(result_map, attribute_name, int)
[attribute_name, "date_register"] ->
{:ok, date, _} = DateTime.from_iso8601(attribute_value)
Map.put(result_map, attribute_name, date)
[attribute_name, "binarydata_register"] ->
Map.put(result_map, attribute_name, {:binary_data, attribute_value})
_ ->
result_map
end
else
result_map
end
end
defp build_riak_filter({:attrExp, attrExp}) do
build_riak_filter(attrExp)
end
defp build_riak_filter({:and, lhs, rhs}) do
"(" <> build_riak_filter(lhs) <> " AND " <> build_riak_filter(rhs) <> ")"
end
defp build_riak_filter({:or, lhs, rhs}) do
"(" <> build_riak_filter(lhs) <> ") OR (" <> build_riak_filter(rhs) <> ")"
end
defp build_riak_filter({:not, filter}) do
"(*:* NOT " <> build_riak_filter(filter) <> ")"
end
defp build_riak_filter(
{:pr,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}}
) do
attribute <>
"_register:* OR " <>
attribute <>
"_integer_register:* OR " <>
attribute <>
"_date_register:* OR " <>
attribute <>
"_binarydata_register:* OR " <>
attribute <> "_flag:* OR " <> attribute <> "_counter:* OR " <> attribute <> "_set:*"
end
defp build_riak_filter(
{:eq,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(value) do
# special case to handle equality in sets
attribute <>
"_register:" <>
to_escaped_string(value) <> " OR " <> attribute <> "_set:" <> to_escaped_string(value)
end
defp build_riak_filter(
{:eq,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_boolean(value) or is_integer(value) do
riak_attribute_name(attribute, value) <> ":" <> to_string(value)
end
defp build_riak_filter(
{:eq,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, %DateTime{} = value}
) do
riak_attribute_name(attribute, value) <>
":[" <> DateTime.to_iso8601(value) <> " TO " <> DateTime.to_iso8601(value) <> "]"
end
defp build_riak_filter(
{:eq,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, {:binary_data, value}}
) do
riak_attribute_name(attribute, value) <> ":" <> to_string(value)
end
defp build_riak_filter({:ne, attribute_path, value}) do
"(*:* NOT " <> build_riak_filter({:eq, attribute_path, value}) <> ")"
end
defp build_riak_filter(
{:ge,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(value) or is_integer(value) do
riak_attribute_name(attribute, value) <> ":[" <> to_escaped_string(value) <> " TO *]"
end
defp build_riak_filter(
{:ge,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, %DateTime{} = value}
) do
riak_attribute_name(attribute, value) <> ":[" <> DateTime.to_iso8601(value) <> " TO *]"
end
defp build_riak_filter(
{:le,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(value) or is_integer(value) do
riak_attribute_name(attribute, value) <> ":[* TO " <> to_escaped_string(value) <> "]"
end
defp build_riak_filter(
{:le,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, %DateTime{} = value}
) do
riak_attribute_name(attribute, value) <> ":[* TO " <> DateTime.to_iso8601(value) <> "]"
end
defp build_riak_filter(
{:gt,
%AttributePath{
attribute: attribute,
sub_attribute: nil
} = attribute_path, value}
)
when is_binary(value) or is_integer(value) do
# attribute does exist
"(" <>
riak_attribute_name(attribute, value) <>
":* AND " <> "(*:* NOT " <> build_riak_filter({:le, attribute_path, value}) <> "))"
end
defp build_riak_filter(
{:gt,
%AttributePath{
attribute: attribute,
sub_attribute: nil
} = attribute_path, %DateTime{} = value}
) do
# attribute does exist
"(" <>
riak_attribute_name(attribute, value) <>
":* AND " <> "(*:* NOT " <> build_riak_filter({:le, attribute_path, value}) <> "))"
end
defp build_riak_filter(
{:lt,
%AttributePath{
attribute: attribute,
sub_attribute: nil
} = attribute_path, value}
)
when is_binary(value) or is_integer(value) do
# attribute does exist
"(" <>
riak_attribute_name(attribute, value) <>
":* AND " <> "(*:* NOT " <> build_riak_filter({:ge, attribute_path, value}) <> "))"
end
defp build_riak_filter(
{:lt,
%AttributePath{
attribute: attribute,
sub_attribute: nil
} = attribute_path, %DateTime{} = value}
) do
# attribute does exist
"(" <>
riak_attribute_name(attribute, value) <>
":* AND " <> "(*:* NOT " <> build_riak_filter({:ge, attribute_path, value}) <> "))"
end
defp build_riak_filter(
{:co,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(attribute) do
# special case to handle equality in sets
attribute <>
"_register:*" <>
to_escaped_string(value) <>
"* OR " <> attribute <> "_set:*" <> to_escaped_string(value) <> "*"
end
defp build_riak_filter(
{:sw,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(attribute) do
# special case to handle equality in sets
attribute <>
"_register:" <>
to_escaped_string(value) <>
"* OR " <> attribute <> "_set:" <> to_escaped_string(value) <> "*"
end
defp build_riak_filter(
{:ew,
%AttributePath{
attribute: attribute,
sub_attribute: nil
}, value}
)
when is_binary(attribute) do
# special case to handle equality in sets
attribute <>
"_register:*" <>
to_escaped_string(value) <> " OR " <> attribute <> "_set:*" <> to_escaped_string(value)
end
defp build_riak_filter({_, _, value}) when is_float(value) or is_nil(value) do
raise AttributeRepository.UnsupportedError, message: "Unsupported data type"
end
defp build_riak_filter({_, _, {:ref, _, _}}) do
raise AttributeRepository.UnsupportedError, message: "Unsupported data type"
end
defp riak_attribute_name(name, value) when is_binary(value), do: name <> "_register"
defp riak_attribute_name(name, value) when is_integer(value), do: name <> "_integer_register"
defp riak_attribute_name(name, %DateTime{}), do: name <> "_date_register"
defp riak_attribute_name(name, {:binary_data, _value}), do: name <> "_binarydata_register"
defp riak_attribute_name(name, value) when is_boolean(value), do: name <> "_flag"
@spec to_riak_crdt(AttributeRepository.attribute_data_type()) :: any()
defp to_riak_crdt(value) when is_binary(value) do
Riak.CRDT.Register.new(value)
end
defp to_riak_crdt(true) do
Riak.CRDT.Flag.new()
|> Riak.CRDT.Flag.enable()
end
defp to_riak_crdt(false) do
Riak.CRDT.Flag.new()
|> Riak.CRDT.Flag.disable()
end
defp to_riak_crdt(value) when is_integer(value) do
value
|> to_string()
|> Riak.CRDT.Register.new()
end
defp to_riak_crdt(%DateTime{} = value) do
value
|> DateTime.to_iso8601()
|> Riak.CRDT.Register.new()
end
defp to_riak_crdt({:binary_data, value}) do
Riak.CRDT.Register.new(value)
end
defp to_riak_crdt(value) when is_list(value) do
Enum.reduce(
value,
Riak.CRDT.Set.new(),
fn
list_element, acc ->
Riak.CRDT.Set.put(acc, list_element)
end
)
end
defp to_escaped_string(value) do
value
|> to_string()
|> String.replace(" ", "\\ ")
end
@spec bucket_name(AttributeRepository.run_opts()) :: String.t()
defp bucket_name(run_opts), do: "attribute_repository_" <> to_string(run_opts[:instance])
@spec index_name(AttributeRepository.run_opts()) :: String.t()
defp index_name(run_opts),
do: "attribute_repository_" <> to_string(run_opts[:instance]) <> "_index"
@spec schema_name(AttributeRepository.run_opts()) :: String.t()
def schema_name(_run_opts), do: "attribute_repository_schema"
defp map_entry_data_type_of_key(obj, key) do
keys = Riak.CRDT.Map.keys(obj)
case Enum.find(
keys,
fn
{^key, _} ->
true
_ ->
false
end
) do
{^key, type} ->
type
_ ->
nil
end
end
end
|
lib/attribute_repository_riak.ex
| 0.630344 | 0.418578 |
attribute_repository_riak.ex
|
starcoder
|
defmodule Zaryn.OracleChain.Summary do
@moduledoc false
alias Zaryn.Crypto
alias Zaryn.TransactionChain.Transaction
alias Zaryn.TransactionChain.Transaction.ValidationStamp
alias Zaryn.TransactionChain.TransactionData
defstruct [:transactions, :previous_date, :date, :aggregated]
@type t :: %__MODULE__{
transactions: list(Transaction.t()) | Enumerable.t(),
previous_date: DateTime.t() | nil,
date: DateTime.t() | nil,
aggregated:
%{
DateTime.t() => map()
}
| nil
}
@doc ~S"""
Aggregate the oracle chain data into a single map
## Examples
iex> %Summary{ transactions: [
...> %Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:10:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.02, \"usd\":0.018}}"}},
...> %Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:00:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.021, \"usd\":0.019}}"}}
...> ]}
...> |> Summary.aggregate()
%Summary{
transactions: [
%Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:10:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.02, \"usd\":0.018}}"}},
%Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:00:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.021, \"usd\":0.019}}"}}
],
aggregated: %{
~U[2021-04-29 13:00:00Z] => %{ "zaryn" => %{ "eur" => 0.021, "usd" => 0.019 }},
~U[2021-04-29 13:10:00Z] => %{ "zaryn" => %{ "eur" => 0.02, "usd" => 0.018 }}
}
}
"""
@spec aggregate(t()) :: t()
def aggregate(summary = %__MODULE__{transactions: transactions}) do
aggregated =
transactions
|> Stream.map(fn %Transaction{
data: %TransactionData{content: content},
validation_stamp: %ValidationStamp{timestamp: timestamp}
} ->
data = Jason.decode!(content)
{DateTime.truncate(timestamp, :second), data}
end)
|> Enum.into(%{})
%{summary | aggregated: aggregated}
end
@doc ~S"""
Verify if the aggregated data is correct from the list transaction passed
## Examples
iex> %Summary{
...> aggregated: %{
...> ~U[2021-04-29 13:00:00Z] => %{ "zaryn" => %{ "eur" => 0.021, "usd" => 0.019 }},
...> ~U[2021-04-29 13:10:00Z] => %{ "zaryn" => %{ "eur" => 0.02, "usd" => 0.018 }}
...> },
...> transactions: [
...> %Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:10:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.02, \"usd\":0.018}}"}},
...> %Transaction{validation_stamp: %ValidationStamp{timestamp: ~U[2021-04-29 13:00:00Z]}, data: %TransactionData{content: "{\"zaryn\":{\"eur\":0.021, \"usd\":0.019}}"}}
...> ]
...> } |> Summary.verify?()
true
"""
@spec verify?(t()) :: boolean()
def verify?(%__MODULE__{transactions: transactions, aggregated: aggregated}) do
%__MODULE__{aggregated: transaction_lookup} =
%__MODULE__{transactions: transactions} |> aggregate()
Enum.all?(aggregated, fn {timestamp, data} ->
case Map.get(transaction_lookup, timestamp) do
^data ->
true
_ ->
false
end
end)
end
@doc """
Build a transaction from the oracle chain's summary
"""
@spec to_transaction(t()) :: Transaction.t()
def to_transaction(%__MODULE__{
aggregated: aggregated_data,
previous_date: previous_date,
date: date
}) do
{prev_pub, prev_pv} = Crypto.derive_oracle_keypair(previous_date)
{next_pub, _} = Crypto.derive_oracle_keypair(date)
Transaction.new(
:oracle_summary,
%TransactionData{
code: """
# We stop the inheritance of transaction by ensuring no other
# summary transaction will continue on this chain
condition inherit: [ content: "" ]
""",
content:
aggregated_data
|> Enum.map(&{DateTime.to_unix(elem(&1, 0)), elem(&1, 1)})
|> Enum.into(%{})
|> Jason.encode!()
},
prev_pv,
prev_pub,
next_pub
)
end
end
|
lib/zaryn/oracle_chain/summary.ex
| 0.87672 | 0.423756 |
summary.ex
|
starcoder
|
defmodule StepFlow.WorkflowDefinitionController do
use StepFlow, :controller
use BlueBird.Controller
import Plug.Conn
alias StepFlow.Controller.Helpers
alias StepFlow.WorkflowDefinitions
alias StepFlow.WorkflowDefinitions.WorkflowDefinition
require Logger
action_fallback(StepFlow.FallbackController)
def index(%Plug.Conn{assigns: %{current_user: user}} = conn, params) do
params =
params
|> Map.put("rights", StepFlow.Map.get_by_key_or_atom(user, :rights, []))
workflow_definitions = WorkflowDefinitions.list_workflow_definitions(params)
conn
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("index.json", workflow_definitions: workflow_definitions)
end
def index(conn, _) do
conn
|> put_status(403)
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("error.json",
errors: %{reason: "Forbidden to view workflows"}
)
end
def show(%Plug.Conn{assigns: %{current_user: user}} = conn, %{"identifier" => identifier}) do
case WorkflowDefinitions.get_workflow_definition(identifier) do
nil ->
conn
|> put_status(:unprocessable_entity)
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("error.json",
errors: %{reason: "Unable to locate workflow with this identifier"}
)
workflow_definition ->
if Helpers.has_right(workflow_definition, user, "view") do
conn
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("show.json", workflow_definition: workflow_definition)
else
conn
|> put_status(:forbidden)
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("error.json",
errors: %{reason: "Forbidden to access workflow definition with this identifier"}
)
end
end
end
def show(conn, _) do
conn
|> put_status(403)
|> put_view(StepFlow.WorkflowDefinitionView)
|> render("error.json",
errors: %{reason: "Forbidden to view workflow with this identifier"}
)
end
def create(conn, _) do
workflows = WorkflowDefinition.load_workflows_in_database()
Logger.info("#{inspect(workflows)}")
json(conn, %{})
end
end
|
lib/step_flow/controllers/workflow_definition_controller.ex
| 0.504883 | 0.441312 |
workflow_definition_controller.ex
|
starcoder
|
defmodule Mix.Tasks.Stats do
@moduledoc false
use Mix.Task
def get_datum(module, learn_val, args) do
to_train = module.new(args)
role_model = module.new(args)
{_, info} = NeuralNet.Tester.test_training(to_train, role_model, 100, 10, learn_val, 2, 0, false)
{info.eval_time, info.iterations}
end
def perform_statistics(str, data) do
n = length(data)
mean = Enum.reduce data, 0, fn diff, mean ->
mean + (diff / n)
end
variance = Enum.reduce data, 0, fn datum, var ->
var + (:math.pow(datum - mean, 2) / (n - 1))
end
sd = :math.sqrt(variance)
digits = 5
IO.puts "#{str} | Mean: #{Float.round(mean, digits)}, SD: #{Float.round(sd, digits)}, N: #{n}"
end
def compare(module1, module2, argfun1, argfun2, sample_size \\ 200) do
{time_data, its_data} = Enum.reduce 1..sample_size, {[], []}, fn num, {time_data, its_data} ->
learn_val = 0.5 + :random.uniform*2.5
IO.write "\rCollecting data sample #{num}/#{sample_size} with learn_val #{Float.round(learn_val, 3)}"
{time1, iterations1} = get_datum(module1, learn_val, argfun1.())
{time2, iterations2} = get_datum(module2, learn_val, argfun2.())
{[time1 - time2 | time_data], [iterations1 - iterations2 | its_data]}
end
IO.puts ""
perform_statistics("Time ", time_data)
perform_statistics("Iterations", its_data)
end
def get_data(module, argfun, sample_size \\ 200, record \\ false) do
time_file = if record, do: File.open!("#{inspect(module)}_time.dat", [:write])
iterations_file = if record, do: File.open!("#{inspect(module)}_iterations.dat", [:write])
{time_data, its_data} = Enum.reduce 1..sample_size, {[], []}, fn num, {time_data, its_data} ->
learn_val = 0.5 + :random.uniform*2.5
IO.write "\rCollecting #{inspect(module)} data sample #{num}/#{sample_size} with learn_val #{Float.round(learn_val, 3)}"
{time, iterations} = get_datum(module, learn_val, argfun.())
if record do
IO.puts(time_file, time)
IO.puts(iterations_file, iterations)
end
{[time | time_data], [iterations | its_data]}
end
if record do
File.close(time_file)
File.close(iterations_file)
end
IO.puts ""
perform_statistics("#{inspect(module)} Time ", time_data)
perform_statistics("#{inspect(module)} Iterations", its_data)
end
def run(_) do
argfun = fn ->
in_size = 1+:random.uniform(9)
out_size = 1+:random.uniform(9)
mem_size = 1+:random.uniform(9)
%{input_ids: Enum.to_list(1..in_size), output_ids: Enum.to_list(1..out_size), memory_size: mem_size}
end
# compare(GRU, GRUM, argfun, argfun)
get_data(GRU, argfun, 200, true)
get_data(GRUM, argfun, 200, true)
end
end
|
lib/mix/tasks/stats.ex
| 0.512693 | 0.498718 |
stats.ex
|
starcoder
|
defmodule SSTable do
@moduledoc """
# Specification of Sorted String Table files
A Sorted String Table contains zero or more _gzipped key/value chunks_.
## GZipped key/value chunks
A _gzip key/value chunk_ follows this binary specification:
1. Four bytes: length of the gzipped chunk
2. Variable length: gzipped chunk of key/value pairs, with tombstones.
## Unzipped key/value chunks
Once unzipped, each key/value chunk contains zero or more key/value records.
Each record describes its own length. Some keys may point to
tombstones.
### Value records
1. Four bytes: Length of key
2. Four bytes: Length of value
3. Variable length: Raw key, not escaped
4. Variable length: Raw value, not escaped
### Tombstone records
1. Four bytes: Length of key in bytes
2. Four bytes: `2^32 - 1` to indicate tombstone
3. Variable length: Raw key, not escaped
"""
import SSTable.Settings
defstruct [:index, :table]
@doc """
Query all SSTable files using their associated index file and a key,
returning a value if present. Filters tombstone entries.
There must be an associated `<timestamp>.idx` file present for each SSTable,
or the private query function will fail.
This function returns `:tombstone` in the case of deleted entries.
## Examples
### As used during a normal run
Pass a MapSet of paths to exclude from
the tables queried.
```elixir
SSTable.query("a", CuckooFilter.eliminate("a"))
```
### Basic query
```elixir
SSTable.query("a")
```
### Combined with Memtable
```elixir
Memtable.update("bar","BAZ"); Memtable.delete("foo"); Memtable.flush()
:ok
SSTable.query("bar")
"BAZ"
SSTable.query("foo")
:tombstone
SSTable.query("a")
:none
```
"""
def query(key, exclude_paths \\ MapSet.new()) do
sst_files =
Path.wildcard("*.sst")
|> Enum.sort()
|> Enum.reverse()
|> Enum.filter(&(!MapSet.member?(exclude_paths, &1)))
query_all(key, sst_files)
end
@doc """
Write a list of key/value pairs to binary SSTable file (<timestamp>.sst)
Also write a sparse index of offsets (<timestamp>.idx)
## Example
```elixir
tree = :gb_trees.enter("k3","uuu",:gb_trees.enter("k2","ww",:gb_trees.enter("k1","v",:gb_trees.empty())))
SSTable.dump(tree)
```
"""
def dump(gb_tree) do
maybe_kvs =
for entry <- :gb_trees.to_list(gb_tree) do
case entry do
{key, {:value, value, _time}} -> {key, value}
{key, {:tombstone, _time}} -> {key, :tombstone}
_ -> nil
end
end
kvs = Enum.filter(maybe_kvs, &(&1 != nil))
{payload, sparse_index} = SSTable.Zip.zip(kvs)
time = :erlang.system_time()
sst_path = new_filename(time)
idx_path = "#{time}.idx"
File.write!(sst_path, payload)
File.write!(idx_path, :erlang.term_to_binary(sparse_index))
IO.puts("Dumped SSTable to #{sst_path}")
{sst_path, sparse_index}
end
def new_filename(time_name \\ :erlang.system_time()) do
"#{time_name}.sst"
end
defp query_all(_key, []) do
:none
end
defp query_all(key, [sst_file | rest]) do
case query_file(key, sst_file) do
:none -> query_all(key, rest)
:tombstone -> :tombstone
value -> value
end
end
@tombstone tombstone()
@gzip_length_bytes SSTable.Settings.gzip_length_bytes()
defp query_file(key, sst_filename) when is_binary(sst_filename) do
index = SSTable.Index.fetch(sst_filename)
nearest_offset =
case find_nearest_offset(index, key) do
nil -> :none
offset -> offset
end
case nearest_offset do
:none ->
:none
offset ->
{:ok, sst} = :file.open(sst_filename, [:read, :raw])
{:ok, iod} = :file.pread(sst, offset, @gzip_length_bytes)
<<gzipped_chunk_size::@gzip_length_bytes*8>> = IO.iodata_to_binary(iod)
{:ok, gzipped_chunk} = :file.pread(sst, offset + @gzip_length_bytes, gzipped_chunk_size)
:file.close(sst)
chunk = :zlib.gunzip(IO.iodata_to_binary(gzipped_chunk))
keep_reading(key, chunk)
end
end
@tombstone SSTable.Settings.tombstone()
defp keep_reading(key, chunk) do
case chunk do
"" ->
:none
<<next_key_len::32, next_value_len_tombstone::32, r::binary>> ->
<<next_key::binary-size(next_key_len), s::binary>> = r
{value_or_tombstone, next_vt_len} =
case next_value_len_tombstone do
t when t == @tombstone ->
{:tombstone, 0}
vl ->
<<next_value::binary-size(vl), _::binary>> = IO.iodata_to_binary(s)
{next_value, vl}
end
if next_key == key do
value_or_tombstone
else
case next_vt_len do
0 ->
# no need to skip tombstone
keep_reading(key, s)
n ->
# skip the next value, then keep reading
<<_::binary-size(n), u::binary>> = s
keep_reading(key, u)
end
end
end
end
defp find_nearest_offset(index, key) do
Enum.reduce_while(index, 0, fn {next_key, next_offset}, last_offset ->
case next_key do
n when n > key -> {:halt, last_offset}
n when n == key -> {:halt, next_offset}
_ -> {:cont, next_offset}
end
end)
end
end
|
lib/august_db/sstable/sstable.ex
| 0.886994 | 0.873323 |
sstable.ex
|
starcoder
|
defmodule Is do
@moduledoc ~S"""
Fast, extensible and easy to use data structure validation with nested structures support.
"""
alias Is.{AliasType, Validator, Validators}
@validators_map Validator.to_map(
Application.get_env(:is, :validators, Validators.get_default())
)
@doc ~S"""
Validate data with schema and return list of errors.
## Examples
iex> validate(true, :boolean)
[]
iex> validate(true, boolean: true)
[]
iex> validate(true, boolean: false)
[{:error, [], "must not be a boolean"}]
iex> validate(true, or: [:boolean, :atom])
[]
iex> validate(:ok, or: [:boolean, :atom])
[]
iex> data = Enum.map(1..10, &(%{
...> a: "a",
...> b: true,
...> c: ["a", "b", false],
...> d: [[1, 2, 3], [4, 5, 6]],
...> index: &1,
...> }))
iex> schema = [list: [map: %{
...> a: :binary,
...> b: :boolean,
...> c: [list: [or: [:binary, :boolean]]],
...> d: [list: [list: :integer]],
...> e: [and: [:optional, :binary]],
...> index: [and: [:integer, in_range: [min: 0]]],
...> }]]
iex> validate(data, schema)
[]
iex> data = Enum.map(1..2, &(%{
...> a: 1,
...> b: "b",
...> c: {"a", "b", false},
...> d: [[1, 2, "3"], [4, false, 6]],
...> e: -1,
...> f: "1234567891011",
...> index: &1 - 10,
...> }))
iex> schema = [list: [map: %{
...> a: :binary,
...> b: :boolean,
...> c: [list: [or: [:binary, :boolean]]],
...> d: [list: [list: :integer]],
...> e: [and: [:optional, :binary]],
...> index: [and: [:integer, in_range: [min: 0]]],
...> }]]
iex> validate(data, schema)
[
{:error, [0, :a], "must be a binary"},
{:error, [0, :b], "must be a boolean"},
{:error, [0, :c], "must be a list"},
{:error, [0, :d, 0, 2], "must be an integer"},
{:error, [0, :d, 1, 1], "must be an integer"},
{:error, [0, :e], "must be a binary"},
{:error, [0, :index], "must at least be 0"},
{:error, [1, :a], "must be a binary"},
{:error, [1, :b], "must be a boolean"},
{:error, [1, :c], "must be a list"},
{:error, [1, :d, 0, 2], "must be an integer"},
{:error, [1, :d, 1, 1], "must be an integer"},
{:error, [1, :e], "must be a binary"},
{:error, [1, :index], "must at least be 0"},
]
iex> validate(%{}, :unknown)
{:error, "Validator :unknown does not exist"}
"""
@spec validate(any, any) :: :break | [{:error, [any], binary}]
def validate(data, validator) do
validate(data, validator, [], false)
end
@doc """
Validate data with schema and return list of errors prepend with path, or internal status if nested.
Use given path to prepend all errors.
If nested is true will return internal status (like `:break`),
else will always return normalized errors.
"""
@spec validate(any, any, [any], boolean) :: :break | [{:error, [any], binary}]
def validate(data, validator, path, nested) when is_atom(validator) do
validate(data, [{validator, true}], path, nested)
end
def validate(data, validator, path, nested) when is_tuple(validator) do
validate(data, [validator], path, nested)
end
def validate(data, [{validator, options}], path, nested) when is_atom(validator) do
with {:ok, validator} <- get_validator(validator) do
case apply(validator, :validate, [data, options]) do
:ok -> []
:break when nested === true -> :break
:break when nested === false -> []
{:error, nested_path, error} -> [{:error, path ++ nested_path, error}]
{:error, error} -> [{:error, path, error}]
errors when is_list(errors) -> normalize_errors(errors, path)
end
else
{:error, error} -> {:error, error}
end
end
def validate(data, options, path, nested) do
case get_alias(options) do
{:ok, type} -> validate(data, [{type, options}], path, nested)
{:ok, type, nested_options} ->
validate(data, [{type, nested_options}], path, nested)
{:error, error} -> {:error, error}
end
end
@doc ~S"""
Returns true if data is valid, else false.
## Examples
iex> valid?(true, :boolean)
true
iex> valid?(true, boolean: true)
true
iex> valid?(true, boolean: false)
false
iex> valid?(true, or: [:boolean, :atom])
true
iex> valid?(:ok, or: [:boolean, :atom])
true
iex> data = Enum.map(1..10, &(%{
...> a: "a",
...> b: true,
...> c: ["a", "b", false],
...> d: [[1, 2, 3], [4, 5, 6]],
...> index: &1,
...> }))
iex> schema = [list: [map: %{
...> a: :binary,
...> b: :boolean,
...> c: [list: [or: [:binary, :boolean]]],
...> d: [list: [list: :integer]],
...> e: [and: [:optional, :binary]],
...> index: [and: [:integer, in_range: [min: 0]]],
...> }]]
iex> valid?(data, schema)
true
iex> data = Enum.map(1..2, &(%{
...> a: 1,
...> b: "b",
...> c: {"a", "b", false},
...> d: [[1, 2, "3"], [4, false, 6]],
...> e: -1,
...> f: "1234567891011",
...> index: &1 - 10,
...> }))
iex> schema = [list: [map: %{
...> a: :binary,
...> b: :boolean,
...> c: [list: [or: [:binary, :boolean]]],
...> d: [list: [list: :integer]],
...> e: [and: [:optional, :binary]],
...> index: [and: [:integer, in_range: [min: 0]]],
...> }]]
iex> valid?(data, schema)
false
iex> valid?(true, {:boolean, true})
true
iex> valid?(%{a: true}, %{a: :boolean})
true
iex> valid?(%{}, :unknown)
{:error, "Validator :unknown does not exist"}
"""
@spec valid?(any, any) :: boolean | {:error, binary}
def valid?(data, validator) do
valid?(data, validator, [], false)
end
@spec valid?(any, any, [any], boolean) :: boolean | {:error, binary}
def valid?(data, validator, path, nested) when is_atom(validator) do
valid?(data, [{validator, true}], path, nested)
end
def valid?(data, validator, path, nested) when is_tuple(validator) do
valid?(data, [validator], path, nested)
end
def valid?(data, [{validator, options}], _path, _nested) when is_atom(validator) do
with {:ok, validator} <- get_validator(validator) do
case apply(validator, :validate, [data, options]) do
:ok -> true
[] -> true
:break -> true
_ -> false
end
else
{:error, error} -> {:error, error}
end
end
def valid?(data, options, path, nested) do
case get_alias(options) do
{:ok, type} -> valid?(data, [{type, options}], path, nested)
{:ok, type, nested_options} ->
valid?(data, [{type, nested_options}], path, nested)
{:error, error} -> {:error, error}
end
end
@doc """
Returns validator associate with given id if any.
"""
@spec get_validator(atom) :: {:ok, atom} | {:error, any}
def get_validator(id) do
Validator.get(@validators_map, id)
end
@doc """
Returns alias associate with given value if any.
"""
@spec get_alias(any) :: {:ok, atom} | {:ok, atom, boolean | Keyword.t} |
{:error, any}
def get_alias(value) do
AliasType.get(value)
end
@doc """
Returns given errors normalized.
"""
@spec normalize_errors([any], [any]) :: [{:error, [any], [any]}]
def normalize_errors(errors, path) when is_list(errors) and is_list(path) do
Enum.map(errors, fn
{:error, error} -> {:error, path, error}
{:error, nested_path, error} -> {:error, path ++ nested_path, error}
{nested_path, error} -> {:error, path ++ nested_path, error}
end)
end
end
|
lib/is.ex
| 0.900696 | 0.658843 |
is.ex
|
starcoder
|
defmodule Firmata.Board do
use GenServer
use Firmata.Protocol.Mixin
require Logger
alias Firmata.Protocol.State, as: ProtocolState
@initial_state %{
pins: [],
outbox: [],
processor_pid: nil,
parser: {},
firmware_name: "",
interface: nil,
serial: nil
}
def start_link(port, opts \\ [], name \\ nil) do
opts = Keyword.put(opts, :interface, self)
GenServer.start_link(__MODULE__, {port, opts}, name: name)
end
def stop(pid) do
GenServer.call(pid, :stop)
end
def report_analog_channel(board, channel, value) do
GenServer.call(board, {:report_analog_channel, channel, value})
end
def set_pin_mode(board, pin, mode) do
GenServer.call(board, {:set_pin_mode, pin, mode})
end
def pin_state(board, pin) do
board |> sysex_write(@pin_state_query, <<pin>>)
end
def digital_write(board, pin, value) do
GenServer.call(board, {:digital_write, pin, value})
end
def sonar_config(board, trigger, echo, max_distance, ping_interval) do
set_pin_mode(board, trigger, @sonar)
set_pin_mode(board, echo, @sonar)
max_distance_lsb = max_distance &&& 0x7f
max_distance_msb = (max_distance >>> 7) &&& 0x7f
data = <<trigger, echo, max_distance_lsb, max_distance_msb, ping_interval>>
board |> sysex_write(@sonar_config, data)
end
def neopixel_register(board, pin, num_pixels) do
data = <<pin, num_pixels>>
board |> sysex_write(@neopixel_register, data)
end
def neopixel(board, index, {r, g, b}) do
data = <<index, r, g, b>>
board |> sysex_write(@neopixel, data)
end
def neopixel_brightness(board, brightness) do
data = <<brightness>>
board |> sysex_write(@neopixel_brightness, data)
end
def sysex_write(board, cmd, data) do
GenServer.call(board, {:sysex_write, cmd, data})
end
## Server Callbacks
def init({port, opts}) do
speed = opts[:speed] || 57600
uart_opts = [speed: speed, active: true]
{:ok, serial} = Nerves.UART.start_link
:ok = Nerves.UART.open(serial, port, uart_opts)
Nerves.UART.write(serial, <<0xFF>>)
Nerves.UART.write(serial, <<0xF9>>)
state =
@initial_state
|> Map.put(:serial, serial)
|> Map.put(:interface, opts[:interface])
{:ok, state}
end
def handle_call(:stop, _from, state) do
Process.exit(state[:processor_pid], :normal)
{:reply, :ok, state}
end
def handle_call({:report_analog_channel, channel, value}, {interface, _}, state) do
state = state
|> put_analog_channel(channel, :report, value)
|> put_analog_channel(channel, :interface, interface)
send_data(state, <<@report_analog ||| channel, value>>)
{:reply, :ok, state}
end
def handle_call({:set_pin_mode, pin, mode}, _from, state) do
state = state |> put_pin(pin, :mode, mode)
send_data(state, <<@pin_mode,pin,mode>>)
{:reply, :ok, state}
end
def handle_call({:digital_write, pin, value}, _from, state) do
state = state |> put_pin(pin, :value, value)
signal = state[:pins] |> Firmata.Protocol.digital_write(pin, value)
send_data(state, signal)
{:reply, :ok, state}
end
def handle_call({:sysex_write, cmd, data}, _from, state) do
send_data(state, <<@start_sysex, cmd>> <> data <> <<@end_sysex>>)
{:reply, :ok, state}
end
def handle_info({:nerves_uart, _port, data}, state) do
{outbox, parser} = Enum.reduce(data, {state.outbox, state.parser}, &Firmata.Protocol.parse(&2, &1))
Enum.each(outbox, &send(self, &1))
{:noreply, %{state | outbox: [], parser: parser}}
end
def handle_info({:report_version, major, minor}, state) do
send_data(state, <<@start_sysex, @capability_query, @end_sysex>>)
state = Map.put(state, :version, {major, minor})
send_info(state, {:version, major, minor})
{:noreply, state}
end
def handle_info({:firmware_name, name}, state) do
state = Map.put(state, :firmware_name, name)
send_info(state, {:firmware_name, state[:firmware_name]})
{:noreply, state}
end
def handle_info({:capability_response, pins}, state) do
state = Map.put(state, :pins, pins)
send_data(state, <<@start_sysex, @analog_mapping_query, @end_sysex>>)
{:noreply, state}
end
def handle_info({:analog_mapping_response, mapping}, state) do
pins = state[:pins]
|> Enum.zip(mapping)
|> Enum.map(fn({pin, map})-> Keyword.merge(pin, map) end)
|> Enum.map(fn pin -> Keyword.merge(pin, [interface: nil]) end)
state = Map.put(state, :pins, pins)
send_info(state, {:pin_map, state[:pins]})
{:noreply, state}
end
def handle_info({:analog_read, channel, value }, state) do
state = state |> put_analog_channel(channel, :value, value, fn(pin) ->
send_info(state, {:analog_read, pin[:analog_channel], value}, pin[:interface])
end)
{:noreply, state}
end
def handle_info({:i2c_response, [value: value] }, state) do
send_info(state, {:i2c_response, value})
{:noreply, state}
end
def handle_info({:string_data, [value: value] }, state) do
send_info(state, {:string_data, value |> parse_ascii})
{:noreply, state}
end
def handle_info({:sonar_data, [value: value, pin: pin]}, state) do
send_info(state, {:sonar_data, pin, value})
{:noreply, state}
end
def handle_info({:pin_state, pin, mode, pin_state}, state) do
send_info(state, {:pin_state, pin, mode, pin_state})
{:noreply, state}
end
def handle_info(unknown, state) do
Logger.error("Unknown message in #{__MODULE__}: #{inspect unknown}")
{:noreply, state}
end
defp send_data(state, data), do: Nerves.UART.write(state.serial, data)
defp send_info(state, info, interface \\ nil) do
case interface do
nil -> send_to(state[:interface], {:firmata, info})
_ -> send_to(interface, {:firmata, info})
end
end
defp send_to(interface, message), do: send(interface, message)
defp put_pin(state, index, key, value, found_callback \\ nil) do
pins = state[:pins] |> List.update_at(index, fn(pin) ->
pin = Keyword.put(pin, key, value)
if (found_callback), do: found_callback.(pin)
pin
end)
state = Map.put(state, :pins, pins)
end
defp analog_channel_to_pin_index(state, channel) do
Enum.find_index(state[:pins], fn(pin) ->
pin[:analog_channel] === channel
end)
end
defp put_analog_channel(state, channel, key, value, found_callback \\ nil) do
pin = analog_channel_to_pin_index(state, channel)
put_pin(state, pin, key, value, found_callback)
end
defp parse_ascii(data), do: for n <- data, n != <<0>>, into: "", do: n
end
|
lib/firmata/board.ex
| 0.547948 | 0.409339 |
board.ex
|
starcoder
|
defmodule Cased.Sensitive.String do
@moduledoc """
Used to mask sensitive string values.
"""
@enforce_keys [:data, :label]
defstruct [
:data,
:label
]
@type t :: %__MODULE__{
data: String.t(),
label: nil | atom() | String.t()
}
@type new_opts :: [new_opt()]
@type new_opt :: {:label, String.t() | atom()}
@doc """
Create a new `Cased.Sensitive.String` struct.
## Example
```
Cased.Sensitive.String.new("<EMAIL>", label: :email)
```
"""
@spec new(raw_string :: String.t(), opts :: new_opts()) :: t()
def new(raw_string, opts \\ []) do
%__MODULE__{
data: raw_string,
label: Keyword.get(opts, :label, nil)
}
end
@doc """
Extract all `{begin_offset, end_offset}` values for matches of a given regular expression.
## Examples
```
Cased.Sensitive.String.new("Hello @username and @username")
|> Cased.Sensitive.String.matches(~r/@\w+/)
# => [{6, 15}, {20, 29}]
```
"""
@spec matches(string :: t(), regex :: Regex.t()) :: [{non_neg_integer(), non_neg_integer()}]
def matches(string, regex) do
Regex.scan(regex, string.data, return: :index)
|> List.flatten()
|> Enum.map(fn {offset, length} ->
{offset, offset + length}
end)
end
@doc """
Check two sensitive strings for equality.
## Examples
Two strings with the same data and label are equivalent:
```
iex> string1 = Cased.Sensitive.String.new("text", label: "username")
iex> string2 = Cased.Sensitive.String.new("text", label: "username")
iex> Cased.Sensitive.String.equal?(string1, string2)
true
```
If the contents are different, two sensitive strings are not equal:
```
iex> string1 = Cased.Sensitive.String.new("text", label: "username")
iex> string2 = Cased.Sensitive.String.new("txet", label: "username")
iex> Cased.Sensitive.String.equal?(string1, string2)
false
```
If the labels are different, two sensitive strings are not equal:
```
iex> string1 = Cased.Sensitive.String.new("text", label: "username")
iex> string2 = Cased.Sensitive.String.new("text", label: "email")
iex> Cased.Sensitive.String.equal?(string1, string2)
false
```
"""
@spec equal?(string1 :: t(), string2 :: t()) :: boolean()
def equal?(string1, string2) do
string1.data == string2.data && string1.label == string2.label
end
@spec to_range(string :: t(), key :: String.t()) :: Cased.Sensitive.Range.t()
def to_range(string, key) do
%Cased.Sensitive.Range{
label: string.label,
key: key,
begin_offset: 0,
end_offset: byte_size(string.data)
}
end
end
|
lib/cased/sensitive/string.ex
| 0.915879 | 0.829492 |
string.ex
|
starcoder
|
defmodule Eml.Compiler do
@moduledoc """
Various helper functions for implementing an Eml compiler.
"""
@type chunk :: String.t | { :safe, String.t } | Macro.t
# Options helper
@default_opts [escape: true,
transform: nil,
fragment: false,
compiler: Eml.HTML.Compiler]
defp new_opts(opts), do: Keyword.merge(@default_opts, opts)
# API
@doc """
Compiles eml to a string, or a quoted expression when the input contains
contains quoted expressions too.
Accepts the same options as `Eml.render/3`
In case of error, raises an Eml.CompileError exception.
### Examples:
iex> Eml.Compiler.compile(body(h1(id: "main-title")))
{:safe, "<body><h1 id='main-title'></h1></body>"
"""
@spec compile(Eml.t, Keyword.t) :: { :safe, String.t } | Macro.t
def compile(eml, opts \\ []) do
opts = new_opts(opts)
opts = Keyword.merge(opts[:compiler].opts(), opts)
compile_node(eml, opts, []) |> to_result(opts)
end
@spec precompile(Macro.Env.t, Keyword.t) :: { :safe, String.t } | Macro.t
def precompile(env \\ %Macro.Env{}, opts) do
mod = env.module
mod_opts = if mod && Module.open?(mod),
do: Module.get_attribute(mod, :eml_compile) |> Macro.escape(),
else: []
opts = Keyword.merge(mod_opts, opts)
{ file, opts } = Keyword.pop(opts, :file)
{ block, opts } = Keyword.pop(opts, :do)
ast = if file do
string = File.read!(file)
Code.string_to_quoted!(string, file: file, line: 1)
else
block
end |> prewalk(opts[:fragment])
{ expr, _ } = Code.eval_quoted(ast, [], env)
{ opts, _ } = Code.eval_quoted(opts, [], env)
compile(expr, opts)
end
# Content parsing
@spec compile_node(Eml.t, map, [chunk]) :: [chunk]
def compile_node(list, opts, chunks) when is_list(list) do
Enum.reduce(list, chunks, fn node, chunks ->
compile_node(node, opts, chunks)
end)
end
def compile_node(node, opts, chunks) do
node = node
|> maybe_transform(opts)
|> Eml.Encoder.encode()
case opts[:compiler].compile_node(node, opts, chunks) do
:unhandled ->
default_compile_node(node, opts, chunks)
s ->
s
end
end
@spec default_compile_node(Eml.node_primitive, map, [chunk]) :: [chunk]
defp default_compile_node(node, opts, chunks) when is_binary(node) do
add_chunk(maybe_escape(node, opts), chunks)
end
defp default_compile_node({ :safe, node }, _opts, chunks) when is_binary(node) do
add_chunk(node, chunks)
end
defp default_compile_node(node, _opts, chunks) when is_tuple(node) do
add_chunk(node, chunks)
end
defp default_compile_node(%Eml.Element{template: fun} = node, opts, chunks) when is_function(fun) do
node |> Eml.Element.apply_template() |> compile_node(opts, chunks)
end
defp default_compile_node(nil, _opts, chunks) do
chunks
end
defp default_compile_node(node, _, _) do
raise Eml.CompileError, message: "Bad node primitive: #{inspect node}"
end
# Attributes parsing
@spec compile_attrs(Eml.Element.attrs, map, [chunk]) :: [chunk]
def compile_attrs(attrs, opts, chunks) when is_map(attrs) do
Enum.reduce(attrs, chunks, fn
{ _, nil }, chunks -> chunks
{ k, v }, chunks -> compile_attr(k, v, opts, chunks)
end)
end
@spec compile_attr(atom, Eml.t, map, [chunk]) :: [chunk]
def compile_attr(field, value, opts, chunks) do
opts[:compiler].compile_attr(field, value, opts, chunks)
end
@spec compile_attr_value(Eml.t, map, [chunk]) :: [chunk]
def compile_attr_value(list, opts, chunks) when is_list(list) do
Enum.reduce(list, chunks, fn value, chunks ->
compile_attr_value(value, opts, chunks)
end)
end
def compile_attr_value(value, opts, chunks) do
value = Eml.Encoder.encode(value)
case opts[:compiler].compile_attr_value(value, opts, chunks) do
:unhandled ->
default_compile_node(value, opts, chunks)
s ->
s
end
end
# Text escaping
entity_map = %{"&" => "&",
"<" => "<",
">" => ">",
"\"" => """,
"'" => "'",
"…" => "…"}
def escape(eml) do
Eml.transform(eml, fn
node when is_binary(node) ->
escape(node, "")
node ->
node
end)
end
for {char, entity} <- entity_map do
defp escape(unquote(char) <> rest, acc) do
escape(rest, acc <> unquote(entity))
end
end
defp escape(<<char::utf8, rest::binary>>, acc) do
escape(rest, acc <> <<char::utf8>>)
end
defp escape("", acc) do
acc
end
# Create final result.
defp to_result([{ :safe, string }], _opts) do
{ :safe, string }
end
defp to_result(chunks, opts) do
template = :lists.reverse(chunks)
if opts[:fragment] do
template
else
quote do
Eml.Compiler.concat(unquote(template), unquote(Macro.escape(opts)))
end
end
end
def maybe_transform(node, opts) do
fun = opts[:transform]
if is_function(fun), do: fun.(node), else: node
end
def maybe_escape(node, opts) do
if opts[:escape], do: escape(node, ""), else: node
end
def add_chunk(chunk, [{:safe, safe_chunk} | rest]) when is_binary(chunk) do
[{:safe, safe_chunk <> chunk } | rest]
end
def add_chunk(chunk, chunks) when is_binary(chunk) do
[{ :safe, chunk } | chunks]
end
def add_chunk(chunk, chunks) do
[chunk | chunks]
end
def concat(buffer, opts) do
try do
{ :safe, concat(buffer, "", opts) }
catch
:throw, { :illegal_quoted, stacktrace } ->
reraise Eml.CompileError,
[message: "It's only possible to pass assigns to templates or components when using &"],
stacktrace
end
end
defp concat({ :safe, chunk }, acc, _opts) do
acc <> chunk
end
defp concat(chunk, acc, opts) when is_binary(chunk) do
acc <> maybe_escape(chunk, opts)
end
defp concat([chunk | rest], acc, opts) do
concat(rest, concat(chunk, acc, opts), opts)
end
defp concat([], acc, _opts) do
acc
end
defp concat(nil, acc, _opts) do
acc
end
defp concat(node, acc, opts) do
case Eml.Compiler.compile(node, opts) do
{ :safe, chunk } ->
acc <> chunk
_ ->
throw { :illegal_quoted, System.stacktrace() }
end
end
def prewalk(quoted, fragment?) do
handler = if fragment?,
do: &handle_fragment/1,
else: &handle_template/1
Macro.prewalk(quoted, handler)
end
defp handle_fragment({ :@, meta, [{ name, _, atom }] }) when is_atom(name) and is_atom(atom) do
line = meta[:line] || 0
Macro.escape(quote line: line do
Access.get(var!(assigns), unquote(name))
end)
end
defp handle_fragment({ :&, _meta, [{ _fun, _, args }] } = ast) do
case Macro.prewalk(args, false, &handle_capture_args/2) do
{ _, true } ->
ast
{ _, false } ->
raise Eml.CompileError,
message: "It's not possible to use & inside fragments"
end
end
defp handle_fragment(arg) do
arg
end
defp handle_template({ :&, meta, [{ fun, _, args }] }) do
case Macro.prewalk(args, false, &handle_capture_args/2) do
{ _, true } ->
raise Eml.CompileError,
message: "It's not possible to use & for captures inside templates or components"
{ new_args, false } ->
line = Keyword.get(meta, :line, 0)
Macro.escape(quote line: line do
unquote(fun)(unquote_splicing(List.wrap(new_args)))
end)
end
end
defp handle_template({ :@, meta, [{ name, _, atom }]}) when is_atom(name) and is_atom(atom) do
line = Keyword.get(meta, :line, 0)
Macro.escape(quote line: line do
Eml.Compiler.get_assign(unquote(name), var!(assigns), var!(funs))
end)
end
defp handle_template(ast) do
ast
end
defp handle_capture_args({ :@, meta, [{ name, _, atom }]}, regular_capure?) when is_atom(name) and is_atom(atom) do
line = Keyword.get(meta, :line, 0)
ast = quote line: line do
Eml.Compiler.get_assign(unquote(name), var!(assigns), var!(funs))
end
{ ast, regular_capure? }
end
defp handle_capture_args({ :&, _meta, [num]} = ast, _regular_capure?) when is_integer(num) do
{ ast, true }
end
defp handle_capture_args({ :/, _meta, _args} = ast, _regular_capure?) do
{ ast, true }
end
defp handle_capture_args(ast, regular_capure?) do
{ ast, regular_capure? }
end
@doc false
def get_assign(key, assigns, funs) do
x = if is_map(assigns), do: Map.get(assigns, key), else: Keyword.get(assigns, key)
case Keyword.get(funs, key) do
nil -> x
fun -> fun.(x)
end
end
end
|
lib/eml/compiler.ex
| 0.768299 | 0.472623 |
compiler.ex
|
starcoder
|
defmodule Periodic do
@moduledoc """
Periodic job execution.
## Quick start
It is recommended (but not required) to implement the job in a dedicated module. For example:
defmodule SomeCleanup do
def child_spec(_arg) do
Periodic.child_spec(
id: __MODULE__,
run: &run/0,
every: :timer.hours(1)
)
end
defp run(), do: # ...
end
With such module implemented, you can place the job somewhere in the supervision tree:
Supervisor.start_link(
[
SomeCleanup,
# ...
],
# ...
)
You can of course start multiple periodic jobs in the system, and they don't have to be the
children of the same supervisor. You're advised to place the job in the proper part of the
supervision tree. For example, a database cleanup job should share the ancestor with the
repo, while a job working with Phoenix channels should share the ancestor with the
endpoint.
As mentioned, you don't need to create a dedicated module to run a job. It's also possible to
provide `{Periodic, opts}` in the supervisor child list. Finally, if you need more runtime
flexibility, you can also start the job with `start_link/1`.
## Process structure
The process started with `start_link` is called the _scheduler_. This is the process which
regularly "ticks" in the given interval and executes the _job_. The job is executed in a separate
one-off process, which is the child of the scheduler. When the job is done, the job process
stops. Therefore, each job instance is running in a separate process.
Depending on the overlapping mode (see the `:on_overlap` option), it can happen that multiple
instances of the same job are running simultaneously.
## Options
- `:run` (required) - Zero arity function or MFA invoked to run the job. This function is
invoked in a separate one-off process which is a child of the scheduler.
- `:every` (required) - Time in milliseconds between two consecutive job executions (see
`:delay_mode` option for details).
- `:initial_delay` - Time in milliseconds before the first execution of the job. If not provided,
the default value of `:every` is used. In other words, the first execution will by default
take place after the `:initial_delay` interval has passed.
- `:delay_mode` - Controls how the `:every` interval is interpreted. Following options are
possible:
- `:regular` (default) - `:every` represents the time between two consecutive starts
- `:shifted` - `:every` represents the time between the termination of the previous and the
start of the next instance.
See the "Delay mode" section for more details.
- `:when` - Function which acts as an additional runtime guard to decide if the job will be
started. This can be useful for implementing fixed scheduled jobs. See the "Fixed scheduling"
section for details.
- `:on_overlap` - Defines the desired behaviour when the job is about to be started while the
previous instance is still running.
- `:run` (default) - always start the new job
- `:ignore` - don't start the new job if the previous instance is still running
- `:stop_previous` - stop the previous instance before starting the new one
- `:timeout` - Defines the maximum running time of the job. If the job doesn't finish in the
given time, it is forcefully terminated. In this case, the job's shutdown specification is
ignored. Defaults to `:infinity`
- `:job_shutdown` - Shutdown value of the job process. See the "Shutdown" section
for details.
- `:id` - Supervisor child id of the scheduler process. Defaults to `Periodic`. If you plan on
running multiple periodic jobs under the same supervisor, make sure that they have different
id values.
- `:name` - Registered name of the scheduler process. If not provided, the process will not be
registered.
- `:telemetry_id` - Id used in telemetry event names. See the "Telemetry" section for more
details. If not provided, telemetry events won't be emitted.
- `:mode` - When set to `:manual`, the jobs won't be started automatically. Instead you have to
manually send tick signals to the scheduler. This should be used only in `:test` mix env. See
the "Testing" section for details.
## Delay mode
In the `:regular` mode (which is the default), the interval indicates time between two
consecutive starts. This mode is typically useful if you want to maintain a stable execution
rate (the number of executions per some time period). It is also a better choice if you're
implementing fixed scheduling, as advised in the "Fixed scheduling" section.
In the `:shifted` mode the interval represents the pause time between the end of the job and the
start of the next one. This mode is likely a better choice if you want to have a fixed "cool off"
period between two consecutive executions, to reduce the load on the system.
Internally, Periodic relies on Erlang's monotonic time, which improves rate stability regardless
of system time changes (see [Time correction](http://erlang.org/doc/apps/erts/time_correction.html#time-correction)).
Consider using the "Multi-time warp mode" (see [here](http://erlang.org/doc/apps/erts/time_correction.html#time-warp-modes))
to further improve rate stability in the situations when system time changes.
In general, the overhead introduced by Periodic as well as job processing will be compensated,
and you can usually expect stable intervals with very small variations (typically in sub
milliseconds range), and no steady shift over time. However, in some cases, for example when the
system is overloaded, the variations might be more significant.
In the `:shifted` mode the job duration will affect the execution of the next job. In addition,
Periodic will induce a slight (usually less than 100 microseconds), but a steady skew, due to
its own internal processing.
## Shutdown
To stop the scheduler, you need to ask its parent supervisor to stop the scheduler using
[Supervisor.terminate_child](https://hexdocs.pm/elixir/Supervisor.html#terminate_child/2).
The scheduler process acts as a supervisor, and so it has the same shutdown behaviour. When
ordered to terminate by its parent, the scheduler will stop currently running job instances
according to the `:job_shutdown` configuration.
The default behaviour is to wait 5 seconds for the job to finish. However, in order for this
waiting to actually happen, you need to invoke `Process.flag(:trap_exit, true)` from the run
function.
You can change the waiting time with the `:job_shutdown` option, which has the same semantics as
in `Supervisor`. See [corresponding Supervisor documentation]
(https://hexdocs.pm/elixir/Supervisor.html#module-shutdown-values-shutdown) for details.
## Fixed scheduling
Periodic doesn't have explicit support for scheduling jobs at some particular time (e.g. every
day at midnight). However, you can implement this on top of the provided functionality using
the `:when` option
defmodule SomeCleanup do
def child_spec(_arg) do
Periodic.child_spec(
# check every minute if we need to run the cleanup
every: :timer.minutes(1),
# start the job only if it's midnight
when: fn -> match?(%Time{hour: 0, minute: 0}, Time.utc_now()) end,
# ...
)
end
# ...
end
Note that the execution guarantees here are "at most once". If the system is down at the
scheduled time, the job won't be executed. Stronger guarantees can be obtained by basing the
conditional logic on some persistence mechanism.
Note that the `:when` guard is executed in the scheduler process. If the guard execution time is
larger than the ticking period, time drifts will occur.
## Telemetry
The scheduler optionally emits telemetry events. To configure telemetry you need to provide
the `:telemetry_id` option. For example:
Periodic.start_link(telemetry_id: :db_cleanup, ...)
This will emit various events in the shape of `[Periodic, telemetry_id, event]`. Currently
supported events are:
- `:started` - a new job instance is started
- `:finished` - job instance has finished or crashed (see related metadata for the reason)
- `:skipped` - new instance hasn't been started because the previous one is still running
- `:stopped_previous` - previous instance has been stopped because the new one is about to be
started
To consume the desired events, install the corresponding telemetry handler.
## Logging
Basic logger is provided in `Periodic.Logger`. To use it, the scheduler needs to be started with
the `:telemetry_id` option.
To install logger handlers, you can invoke `Periodic.Logger.install(telemetry_id)`. This function
should be invoked only once per each scheduler during the system lifetime, preferably before the
scheduler is started. A convenient place to do it is your application start callback.
## Testing
The scheduler can be deterministically tested by setting the `:mode` option to `:manual`.
In this mode, the scheduler won't tick on its own, and so it won't start any jobs unless
instructed to by the client code.
The `:mode` should be set to `:manual` only in test mix environment. Here's a simple approach
which doesn't require app env and config files:
defmodule MyPeriodicJob do
@mode if Mix.env() != :test, do: :auto, else: :manual
def child_spec(_arg) do
Periodic.child_spec(
mode: @mode,
name: __MODULE__,
# ...
)
end
# ...
end
Of course, you can alternatively use app env or any other approach you prefer. Just make sure
to set the mode to manual only in test env.
Notice that we're also setting the registered name and telemetry id. We'll need both to
interact with the scheduler
With such setup in place, the general shape of the periodic job test would look like this:
def MyPeriodicJobTest do
use ExUnit.Case, async: true
require Periodic.Test
test "my periodic job" do
bring_the_system_into_the_desired_state()
# tick the scheduler
assert Periodic.Test.sync_tick(MyPeriodicJob) == {:ok, :normal}
verify_side_effect_of_the_job()
end
end
Note that this won't suffice for fixed schedules. Consider again the cleanup job which runs
at midnight:
defmodule SomeCleanup do
def child_spec(_arg) do
Periodic.child_spec(
every: :timer.minutes(1),
when: fn -> match?(%Time{hour: 0, minute: 0}, Time.utc_now()) end,
# ...
)
end
# ...
end
Manually ticking won't start the job, unless the test is running exactly at midnight. To make
this module testable, you need to use a different implementation of `:when` in test environment:
defmodule SomeCleanup do
def child_spec(_arg) do
Periodic.child_spec(
every: :timer.minutes(1),
when: &should_run?/0
# ...
)
end
if Mix.env() != :test do
defp should_run?(), do: match?(%Time{hour: 0, minute: 0}, Time.utc_now())
else
defp should_run?(), do: true
end
# ...
end
## Comparison to other schedulers
There are various other abstractions for running periodic jobs in BEAM, such as:
- the built-in [:timer](https://erlang.org/doc/man/timer.html) module from Erlang stdlib
- [erlcron](https://github.com/erlware/erlcron)
- [quantum](https://hexdocs.pm/quantum/readme.html)
- [Oban](https://hexdocs.pm/oban/Oban.html#module-periodic-cron-jobs)
Compared to `:timer`, Periodic offers some additional features, such as overlap handling,
distributed scheduling, and telemetry support.
Compared to most other third party libraries, Periodic will likely provide much less features
out of the box. So in some situations, such as database persistence or back-pressure, you might
need to invest more effort with Periodic. On the plus side Periodic should be simpler to use
in typical scenarios, and much easier to reason about, while still providing enough flexibility
to handle arbitrarily complex scenarios.
For a more detailed discussion, see [this blog post](https://www.theerlangelist.com/article/periodic).
"""
use Parent.GenServer
require Logger
@type opts :: [
id: term,
name: GenServer.name(),
telemetry_id: term,
mode: :auto | :manual,
every: pos_integer,
initial_delay: non_neg_integer,
delay_mode: :regular | :shifted,
run: (() -> term) | {module, atom, [term]},
when: (() -> boolean) | {module, atom, [term]},
on_overlap: :run | :ignore | :stop_previous,
timeout: pos_integer | :infinity,
job_shutdown: :brutal_kill | :infinity | non_neg_integer()
]
@doc "Starts the periodic executor."
@spec start_link(opts) :: GenServer.on_start()
def start_link(opts) do
gen_server_opts = Keyword.take(opts, [:name])
Parent.GenServer.start_link(__MODULE__, Map.new(opts), gen_server_opts)
end
@doc "Builds a child specification for starting the periodic executor."
@spec child_spec(opts) :: Supervisor.child_spec()
def child_spec(opts) do
opts
|> super()
|> Supervisor.child_spec(id: Keyword.get(opts, :id, __MODULE__))
end
@impl GenServer
def init(opts) do
state = Map.merge(defaults(), opts)
{initial_delay, state} = Map.pop(state, :initial_delay, state.every)
enqueue_next_tick(state, initial_delay)
{:ok, state}
end
@impl GenServer
def handle_info({:tick, expected_now}, state) do
handle_tick(state, now: expected_now)
{:noreply, state}
end
@impl GenServer
def handle_call({:tick, opts}, from, %{mode: :manual} = state) do
caller = if Keyword.get(opts, :await_job?), do: from, else: nil
response = handle_tick(state, caller: caller)
cond do
is_nil(caller) -> {:reply, :ok, state}
match?({:ok, _pid}, response) -> {:noreply, state}
true -> {:reply, {:error, :job_not_started}, state}
end
end
@impl Parent.GenServer
def handle_stopped_children(info, state) do
[info] = Map.values(info)
with from when not is_nil(from) <- info.meta.caller,
do: GenServer.reply(from, {:ok, info.exit_reason})
if state.delay_mode == :shifted, do: enqueue_next_tick(state, state.every)
duration =
:erlang.convert_time_unit(
:erlang.monotonic_time() - info.meta.started_at,
:native,
:microsecond
)
telemetry(state, :finished, %{job: info.pid, reason: info.exit_reason}, %{time: duration})
{:noreply, state}
end
defp defaults() do
%{
telemetry_id: nil,
mode: :auto,
delay_mode: :regular,
on_overlap: :run,
timeout: :infinity,
job_shutdown: :timer.seconds(5),
when: nil
}
end
defp handle_tick(state, opts) do
if state.delay_mode == :regular, do: enqueue_next_tick(state, state.every, opts)
if job_guard_satisfied?(state), do: start_job(state, opts)
end
defp job_guard_satisfied?(%{when: nil}), do: true
defp job_guard_satisfied?(%{when: {m, f, a}}), do: apply(m, f, a)
defp job_guard_satisfied?(%{when: fun}) when is_function(fun), do: fun.()
defp start_job(%{on_overlap: :run} = state, opts),
do: start_job_process(state, opts)
defp start_job(%{on_overlap: :ignore} = state, opts) do
case previous_instance() do
{:ok, pid} ->
telemetry(state, :skipped, %{still_running: pid})
nil
:error ->
start_job_process(state, opts)
end
end
defp start_job(%{on_overlap: :stop_previous} = state, opts) do
with {:ok, pid} <- previous_instance() do
Parent.shutdown_all(:kill)
telemetry(state, :stopped_previous, %{pid: pid})
end
start_job_process(state, opts)
end
defp start_job_process(state, opts) do
job = state.run
{:ok, pid} =
Parent.start_child(%{
id: make_ref(),
start: {Task, :start_link, [fn -> invoke_job(job) end]},
timeout: state.timeout,
shutdown: state.job_shutdown,
restart: :temporary,
meta: %{started_at: :erlang.monotonic_time(), caller: Keyword.get(opts, :caller)},
ephemeral?: true
})
telemetry(state, :started, %{job: pid})
{:ok, pid}
end
defp invoke_job({mod, fun, args}), do: apply(mod, fun, args)
defp invoke_job(fun) when is_function(fun, 0), do: fun.()
defp previous_instance() do
case Parent.children() do
[child] -> {:ok, child.pid}
[] -> :error
end
end
defp enqueue_next_tick(state, delay, opts \\ []) do
telemetry(state, :next_tick, %{in: delay})
if state.mode == :auto do
now = Keyword.get_lazy(opts, :now, fn -> :erlang.monotonic_time(:millisecond) end)
next_tick_abs_time = now + delay
Process.send_after(self(), {:tick, next_tick_abs_time}, next_tick_abs_time, abs: true)
end
end
defp telemetry(state, event, data, measurements \\ %{})
if Mix.env() != :test do
defp telemetry(_state, :next_tick, _data, _measurements), do: :ok
end
defp telemetry(%{telemetry_id: nil}, _event, _data, _measurements), do: :ok
defp telemetry(state, event, data, measurements) do
:telemetry.execute(
[__MODULE__, state.telemetry_id, event],
measurements,
Map.merge(data, %{scheduler: self()})
)
end
end
|
lib/periodic.ex
| 0.895517 | 0.745375 |
periodic.ex
|
starcoder
|
defmodule LogiStd.Sink.File do
@moduledoc """
A sink which writes log messages to a file.
## Note
The sink has no overload protections,
so it is recommended to use it together with (for example) `Logi.Sink.Flowlimiter`
in a production environment.
(See also `LogiStd.Sink.Ha`)
## Examples
```
iex> sink = LogiStd.Sink.File.new(:sample_file, "sample.log")
iex> {:ok, _} = Logi.Channel.install_sink(sink, :info)
iex> reuire Logi
iex> Logi.info "hello world"
iex> :file.read_file "sample.log"
{:ok, "2016-12-05 23:30:39.810 [info] nonode@nohost <0.159.0> nil:nil:49 [] hello world\\n"}
```
## Memo (TODO: rewrite)
As for the rotation of the log file, the implementation module of `Logi.File.Rotator` is in charge.
(e.g., rotation in units of dates and sizes, deletion of old log files, compression when rotated etc)
The writer process periodically checks the output destination path, and if the log file does not exist,
it is opened again.
However, if the path is the same even if the file (i.e., i-node in the case of unix) has changed,
as in the case of being overwritten,
Care should be taken because the change is not detected.
(Log messages will continue to be written to files that do not already exist)
If the log file can not be opened or written due to disk full or authorization error etc.,
An error of `alert` level is reported using the logger specified when starting writer.
(See also `LogiStd.Sink.Ha`)
"""
@typedoc "A log file path."
@type filepath :: binary
@typedoc """
Options for this sink.
### layout
- The layout instance used by the sink
- Default: `LogiStd.Sink.File.default_layout`
### logger
- The logger instance which is used to report internal events of the sink process
- Default: `Logi.default_logger`
### rotator
- The rotator instance used by the sink
- Default: `LogiStd.File.Rotator.Noop.new`
### open_opt
- Log file open options (i.e., the second argument of `:file:open/2`)
- Default: `[:append, :raw, :delayed_write]`
"""
@type options :: [
layout: Logi.Layout.layout,
logger: Logi.logger,
rotator: LogiStd.File.Rotator.rotator,
open_opt: open_options
]
@typedoc """
Log file open options.
See [file:mode/0](http://www.erlang.org/doc/man/file.html#type-mode) for more details.
"""
@type open_options :: list
@doc "Creates a new sink."
@spec new(Logi.Sink.id, :file.name_all, options) :: Logi.Sink.sink
def new(sink_id, filepath, options \\ []) do
:logi_sink_file.new sink_id, filepath, options
end
@doc """
Default layout.
Returns `LogiStd.Layout.Default.new |> LogiStd.Layout.Limit.new |> LogiStd.Layout.Newline.new`.
"""
@spec default_layout :: Logi.Layout.layout
def default_layout do
:logi_sink_file.default_layout
end
end
|
lib/logi_std/sink/file.ex
| 0.743727 | 0.670864 |
file.ex
|
starcoder
|
defmodule Xxo.State do
@moduledoc """
This module is used to track game state and declare when a user has won/lost.
"""
require Logger
# alias Xxo.Game
@doc """
Checks if there are 3 symbols in a row
"""
def winner?(symbol, state) do
won(symbol, state.board)
end
### Top row win
defp won(
player,
%{
{0, 0} => player,
{0, 1} => player,
{0, 2} => player,
{1, 0} => _,
{1, 1} => _,
{1, 2} => _,
{2, 0} => _,
{2, 1} => _,
{2, 2} => _
} = _board
),
do: {:winner, player}
# Middle row win
defp won(
player,
%{
{0, 0} => _,
{0, 1} => _,
{0, 2} => _,
{1, 0} => player,
{1, 1} => player,
{1, 2} => player,
{2, 0} => _,
{2, 1} => _,
{2, 2} => _
} = _board
),
do: {:winner, player}
# Bottom row win
defp won(
player,
%{
{0, 0} => _,
{0, 1} => _,
{0, 2} => _,
{1, 0} => _,
{1, 1} => _,
{1, 2} => _,
{2, 0} => player,
{2, 1} => player,
{2, 2} => player
} = board
),
do: {:winner, player}
# Left column win
defp won(
player,
%{
{0, 0} => player,
{0, 1} => _,
{0, 2} => _,
{1, 0} => player,
{1, 1} => _,
{1, 2} => _,
{2, 0} => player,
{2, 1} => _,
{2, 2} => _
} = board
),
do: {:winner, player}
# Middle column win
defp won(
player,
%{
{0, 0} => _,
{0, 1} => player,
{0, 2} => _,
{1, 0} => _,
{1, 1} => player,
{1, 2} => _,
{2, 0} => _,
{2, 1} => player,
{2, 2} => _
} = board
),
do: {:winner, player}
# Right column win
defp won(
player,
%{
{0, 0} => _,
{0, 1} => _,
{0, 2} => player,
{1, 0} => _,
{1, 1} => _,
{1, 2} => player,
{2, 0} => _,
{2, 1} => _,
{2, 2} => player
} = board
),
do: {:winner, player}
# Diagonal win, top left -> bottom right
defp won(
player,
%{
{0, 0} => player,
{0, 1} => _,
{0, 2} => _,
{1, 0} => _,
{1, 1} => player,
{1, 2} => _,
{2, 0} => _,
{2, 1} => _,
{2, 2} => player
} = board
),
do: {:winner, player}
# Diagonal win, bottom left -> top right
defp won(
player,
%{
{0, 0} => _,
{0, 1} => _,
{0, 2} => player,
{1, 0} => _,
{1, 1} => player,
{1, 2} => _,
{2, 0} => player,
{2, 1} => _,
{2, 2} => _
} = board
),
do: {:winner, player}
# No other function matches - game is still in progress
defp won(_player, _board), do: {:nowinner}
end
|
lib/xxo/state.ex
| 0.586523 | 0.616719 |
state.ex
|
starcoder
|
defmodule Kademlia do
@moduledoc """
Kademlia.ex is in fact a K* implementation. K* star is a modified version of Kademlia
using the same KBuckets scheme to keep track of which nodes to remember. But instead of
using the XOR metric it is using geometric distance on a ring as node value distance.
Node distance is symmetric on the ring.
"""
use GenServer
alias Network.PeerHandler, as: Client
alias Object.Server, as: Server
alias Model.KademliaSql
@k 3
@relay_factor 3
@broadcast_factor 50
defstruct tasks: %{}, network: nil, cache: Lru.new(1024)
@type t :: %Kademlia{tasks: Map.t(), network: KBuckets.t(), cache: Lru.t()}
def start_link(_opts) do
GenServer.start_link(__MODULE__, :ok, name: __MODULE__, hibernate_after: 5_000)
end
@spec ping(any) :: any
def ping(node_id) do
rpc(find_node(node_id), [Client.ping()])
end
@doc """
broadcast is used to broadcast self generated blocks/transactions through the network
"""
def broadcast(msg) do
msg = [Client.publish(), msg]
list = KBuckets.to_list(network())
max = length(list) |> :math.sqrt() |> trunc
num = if max > @broadcast_factor, do: max, else: @broadcast_factor
list
|> Enum.reject(fn a -> KBuckets.is_self(a) end)
|> Enum.take_random(num)
|> Enum.each(fn item -> rpcast(item, msg) end)
end
@doc """
relay is used to forward NEW received blocks/transactions further through the network
"""
def relay(msg) do
msg = [Client.publish(), msg]
KBuckets.next_n(network(), @relay_factor)
|> Enum.each(fn item -> rpcast(item, msg) end)
end
@doc """
store/1 same as store/2 but usees Object.key/1 and Object.encode/1
"""
@spec store(tuple()) :: any()
def store(object) when is_tuple(object) do
key = Object.key(object)
value = Object.encode!(object)
store(key, value)
end
@doc """
store() stores the given key-value pair in the @k nodes
that are closest to the key
"""
@spec store(binary(), binary()) :: any()
def store(key, value) when is_binary(value) do
nodes = find_nodes(key)
key = hash(key)
nearest = KBuckets.nearest_n(nodes, key, @k)
# :io.format("Storing #{value} at ~p as #{Base16.encode(key)}~n", [Enum.map(nearest, &port/1)])
rpc(nearest, [Client.store(), key, value])
end
@doc """
find_value() is different from store() in that it might return
an earlier result
"""
@spec find_value(binary()) :: any()
def find_value(key) do
key = hash(key)
case do_node_lookup(key) do
{_, nearest} ->
nodes = do_find_nodes(key, nearest, KBuckets.k(), Client.find_value())
case nodes do
{:value, value, visited} ->
result = KBuckets.nearest_n(visited, key, KBuckets.k())
call(fn _from, state ->
network = KBuckets.insert_items(state.network, visited)
cache = Lru.insert(state.cache, key, result)
{:reply, :ok, %Kademlia{state | network: network, cache: cache}}
end)
# Kademlia logic: Writing found result to second nearest node
case Enum.at(result, 1) do
nil -> :nothing
second_nearest -> rpcast(second_nearest, [Client.store(), key, value])
end
value
visited ->
call(fn _from, state ->
network = KBuckets.insert_items(state.network, visited)
{:reply, :ok, %Kademlia{state | network: network}}
end)
nil
end
end
end
@spec find_node(Wallet.address()) :: nil | KBuckets.Item.t()
def find_node(address) do
case find_nodes(address) do
[] ->
nil
[first | _] ->
case Wallet.address!(first.node_id) do
^address -> first
_ -> nil
end
end
end
@spec find_nodes(any()) :: [KBuckets.Item.t()]
def find_nodes(key) do
key = hash(key)
case do_node_lookup(key) do
{:cached, result} ->
result
{:network, nearest} ->
visited = do_find_nodes(key, nearest, KBuckets.k(), Client.find_node())
result = KBuckets.nearest_n(visited, key, KBuckets.k())
call(fn _from, state ->
network = KBuckets.insert_items(state.network, visited)
cache = Lru.insert(state.cache, key, result)
{:reply, :ok, %Kademlia{state | network: network, cache: cache}}
end)
result
end
end
@spec find_node_lookup(any()) :: [KBuckets.item()]
def find_node_lookup(key) do
{_, nodes} = do_node_lookup(key)
nodes
end
def network() do
call(fn _from, state -> {:reply, state.network, state} end)
end
def handle_call({:call, fun}, from, state) do
fun.(from, state)
end
def handle_call({:append, key, value, _store_self}, _from, queue) do
KademliaSql.append!(key, value)
{:reply, :ok, queue}
end
def handle_call(:get_network, _from, state) do
{:reply, state.network, state}
end
def handle_call({:register_node, node_id, server}, _from, state) do
{:reply, :ok, register_node(state, node_id, server)}
end
def handle_info(:save, state) do
spawn(fn -> Chain.store_file(Diode.data_dir("kademlia.etf"), state) end)
Process.send_after(self(), :save, 60_000)
{:noreply, state}
end
def handle_info(:contact_seeds, state) do
for seed <- Diode.seeds() do
%URI{userinfo: node_id, host: address, port: port} = URI.parse(seed)
id =
case node_id do
nil -> Wallet.new()
str -> Wallet.from_address(Base16.decode(str))
end
Network.Server.ensure_node_connection(Network.PeerHandler, id, address, port)
end
Process.send_after(self(), :contact_seeds, 60_000)
{:noreply, state}
end
def handle_continue(:seed, state) do
Process.send_after(self(), :save, 60_000)
handle_info(:contact_seeds, state)
{:noreply, state}
end
# Private call used by PeerHandler when connections are established
def handle_cast({:register_node, node_id, server}, state) do
{:noreply, register_node(state, node_id, server)}
end
# Private call used by PeerHandler when is stable for 10 msgs and 30 seconds
def handle_cast({:stable_node, node_id, server}, state) do
case KBuckets.item(state.network, node_id) do
nil ->
{:noreply, register_node(state, node_id, server)}
node ->
network = KBuckets.update_item(state.network, %{node | retries: 0})
if node.retries > 0, do: redistribute(network, node)
{:noreply, %{state | network: network}}
end
end
# Private call used by PeerHandler when connections fail
def handle_cast({:failed_node, node}, state) do
case KBuckets.item(state.network, node) do
nil -> {:noreply, state}
item -> {:noreply, %{state | network: do_failed_node(item, state.network)}}
end
end
defp register_node(state = %Kademlia{network: network}, node_id, server) do
node = %KBuckets.Item{
node_id: node_id,
object: server,
last_seen: System.os_time(:second)
}
network =
if KBuckets.member?(network, node_id) do
KBuckets.update_item(network, node)
else
KBuckets.insert_item(network, node)
end
# Because of bucket size limit, the new node might not get stored
if KBuckets.member?(network, node_id) do
redistribute(network, node)
end
%{state | network: network}
end
def rpc(nodes, call) when is_list(nodes) do
me = self()
ref = make_ref()
Enum.map(nodes, fn node ->
spawn_link(fn ->
send(me, {ref, rpc(node, call)})
end)
end)
|> Enum.map(fn _pid ->
receive do
{^ref, ret} ->
ret
end
end)
end
def rpc(%KBuckets.Item{node_id: node_id} = node, call) do
pid = ensure_node_connection(node)
try do
GenServer.call(pid, {:rpc, call}, 2000)
rescue
error ->
IO.puts("Failed to get a result from #{Wallet.printable(node_id)} #{inspect(error)}")
[]
catch
:exit, {:timeout, _} ->
IO.puts("Timeout while getting a result from #{Wallet.printable(node_id)}")
# TODO: This *always* happens when a node is still syncing. How to handle this better?
# Process.exit(pid, :timeout)
[]
any, what ->
IO.puts(
"Failed(2) to get a result from #{Wallet.printable(node_id)} #{inspect({any, what})}"
)
[]
end
end
def rpcast(%KBuckets.Item{} = node, call) do
GenServer.cast(ensure_node_connection(node), {:rpc, call})
end
@doc """
redistribute resends all key/values that are nearer to the given node to
that node
"""
@max_key 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
def redistribute(network, node) do
node = %KBuckets.Item{} = KBuckets.item(network, node)
# IO.puts("redistribute(#{inspect(node)})")
previ =
case KBuckets.prev_n(network, node, 1) do
[prev] -> KBuckets.integer(prev)
[] -> KBuckets.integer(node)
end
nodei = KBuckets.integer(node)
nexti =
case KBuckets.next_n(network, node, 1) do
[next] -> KBuckets.integer(next)
[] -> KBuckets.integer(node)
end
range_start = rem(div(previ + nodei, 2), @max_key)
range_end = rem(div(nexti + nodei, 2), @max_key)
objs = KademliaSql.objects(range_start, range_end)
# IO.puts("redistribute() -> #{length(objs)}")
Enum.each(objs, fn {key, value} -> rpcast(node, [Client.store(), key, value]) end)
end
# -------------------------------------------------------------------------------------
# Helpers calls
# -------------------------------------------------------------------------------------
def port(nil) do
nil
end
def port(node) do
if is_atom(node.object), do: node.object, else: Object.Server.edge_port(node.object)
end
def init(:ok) do
kb =
Chain.load_file(Diode.data_dir("kademlia.etf"), fn ->
%Kademlia{network: KBuckets.new(Diode.miner())}
end)
{:ok, kb, {:continue, :seed}}
end
@doc "Method used for testing"
def reset() do
call(fn _from, _state ->
{:reply, :ok, %Kademlia{network: KBuckets.new(Diode.miner())}}
end)
end
def append(key, value, store_self \\ false) do
GenServer.call(__MODULE__, {:append, key, value, store_self})
end
# -------------------------------------------------------------------------------------
# Private calls
# -------------------------------------------------------------------------------------
defp ensure_node_connection(%KBuckets.Item{node_id: node_id, object: :self}) do
Network.Server.ensure_node_connection(
Network.PeerHandler,
node_id,
"localhost",
Diode.peer_port()
)
end
defp ensure_node_connection(%KBuckets.Item{node_id: node_id, object: server}) do
host = Server.host(server)
port = Server.peer_port(server)
Network.Server.ensure_node_connection(Network.PeerHandler, node_id, host, port)
end
defp do_failed_node(%{object: :self}, network) do
network
end
defp do_failed_node(item, network) do
now = System.os_time(:second)
case item.retries do
0 ->
KBuckets.update_item(network, %{item | retries: 1, last_seen: now + 5})
failures when failures > 10 ->
# With
# 5 + 5×5 + 5×5×5 + 5×5×5×5 + 5×5×5×5×5 +
# 5x (5×5×5×5×5×5)
# This will delete an item after 24h of failures
IO.puts("Deleting node #{Wallet.printable(item.node_id)} after 10 retries")
KBuckets.delete_item(network, item)
failures ->
factor = min(failures, 5)
next = now + round(:math.pow(5, factor))
KBuckets.update_item(network, %{item | retries: failures + 1, last_seen: next})
end
end
defp do_find_nodes(key, nearest, k, cmd) do
# :io.format("KademliaSearch.find_nodes(key=#{Base16.encode(key)}, nearest=~p, k=#{k}, cmd=#{cmd})~n", [Enum.map(nearest, &port/1)])
KademliaSearch.find_nodes(key, nearest, k, cmd)
end
# Retrieves for the target key either the last cached values or
# the nearest k entries from the KBuckets store
@spec do_node_lookup(any()) :: {:network | :cached, [KBuckets.item()]}
defp do_node_lookup(key) do
call(fn _from, state ->
# case Lru.get(state.cache, key) do
# nil ->
nodes = {:network, KBuckets.nearest_n(state.network, key, KBuckets.k())}
# cached -> {:cached, cached}
# end
# :io.format("do_node_lookup(key) -> ~p, ~p~n", [elem(nodes, 0), length(elem(nodes, 1))])
{:reply, nodes, state}
end)
end
defp call(fun) do
GenServer.call(__MODULE__, {:call, fun})
end
def hash(binary) do
Diode.hash(binary)
end
end
|
lib/kademlia.ex
| 0.839767 | 0.437763 |
kademlia.ex
|
starcoder
|
defmodule Zaryn.BeaconChain.Subset do
@moduledoc """
Represents a beacon slot running inside a process
waiting to receive transactions to register in a beacon slot
"""
alias Zaryn.BeaconChain.Slot
alias Zaryn.BeaconChain.Slot.EndOfNodeSync
alias Zaryn.BeaconChain.Slot.TransactionSummary
alias Zaryn.BeaconChain.SlotTimer
alias Zaryn.BeaconChain.Summary
alias Zaryn.BeaconChain.SummaryTimer
alias __MODULE__.P2PSampling
alias Zaryn.BeaconChain.SubsetRegistry
alias Zaryn.Crypto
alias Zaryn.Election
alias Zaryn.P2P
alias Zaryn.P2P.Message.ReplicateTransaction
alias Zaryn.TransactionChain
alias Zaryn.TransactionChain.Transaction
alias Zaryn.TransactionChain.Transaction.ValidationStamp
alias Zaryn.TransactionChain.TransactionData
alias Zaryn.Utils
use GenServer
require Logger
def start_link(opts) do
subset = Keyword.get(opts, :subset)
GenServer.start_link(__MODULE__, [subset], name: via_tuple(subset))
end
@doc """
Add transaction summary to the current slot for the given subset
"""
@spec add_transaction_summary(subset :: binary(), TransactionSummary.t()) :: :ok
def add_transaction_summary(subset, tx_summary = %TransactionSummary{})
when is_binary(subset) do
GenServer.cast(via_tuple(subset), {:add_transaction_summary, tx_summary})
end
@doc """
Add an end of synchronization to the current slot for the given subset
"""
@spec add_end_of_node_sync(subset :: binary(), EndOfNodeSync.t()) :: :ok
def add_end_of_node_sync(subset, end_of_node_sync = %EndOfNodeSync{}) when is_binary(subset) do
GenServer.cast(via_tuple(subset), {:add_end_of_node_sync, end_of_node_sync})
end
@doc """
Add the beacon slot proof for validation
"""
@spec add_slot(Slot.t(), Crypto.key(), binary()) :: :ok
def add_slot(slot = %Slot{subset: subset}, node_public_key, signature)
when is_binary(node_public_key) and is_binary(signature) do
GenServer.cast(via_tuple(subset), {:add_slot, slot, node_public_key, signature})
end
@doc """
Get the current slot
"""
@spec get_current_slot(binary()) :: Slot.t()
def get_current_slot(subset) when is_binary(subset) do
GenServer.call(via_tuple(subset), :get_current_slot)
end
defp via_tuple(subset) do
{:via, Registry, {SubsetRegistry, subset}}
end
def init([subset]) do
{:ok,
%{
node_public_key: Crypto.first_node_public_key(),
subset: subset,
current_slot: %Slot{subset: subset, slot_time: SlotTimer.next_slot(DateTime.utc_now())}
}}
end
def handle_cast(
{:add_transaction_summary,
tx_summary = %TransactionSummary{address: address, type: type}},
state = %{current_slot: current_slot, subset: subset}
) do
if Slot.has_transaction?(current_slot, address) do
{:reply, :ok, state}
else
current_slot = Slot.add_transaction_summary(current_slot, tx_summary)
Logger.info("Transaction #{type}@#{Base.encode16(address)} added to the beacon chain",
beacon_subset: Base.encode16(subset)
)
# Request the P2P view sampling if the not perfomed from the last 3 seconds
case Map.get(state, :sampling_time) do
nil ->
new_state =
state
|> Map.put(:current_slot, add_p2p_view(current_slot))
|> Map.put(:sampling_time, DateTime.utc_now())
{:noreply, new_state}
time ->
if DateTime.diff(DateTime.utc_now(), time) > 3 do
new_state =
state
|> Map.put(:current_slot, add_p2p_view(current_slot))
|> Map.put(:sampling_time, DateTime.utc_now())
{:noreply, new_state}
else
{:noreply, %{state | current_slot: current_slot}}
end
end
end
end
def handle_cast(
{:add_end_of_node_sync, end_of_sync = %EndOfNodeSync{public_key: node_public_key}},
state = %{current_slot: current_slot, subset: subset}
) do
Logger.info(
"Node #{Base.encode16(node_public_key)} synchronization ended added to the beacon chain",
beacon_subset: Base.encode16(subset)
)
current_slot = Slot.add_end_of_node_sync(current_slot, end_of_sync)
{:noreply, %{state | current_slot: current_slot}}
end
def handle_info(
{:create_slot, time},
state = %{subset: subset, node_public_key: node_public_key, current_slot: current_slot}
) do
if beacon_slot_node?(subset, time, node_public_key) do
handle_slot(time, current_slot, node_public_key)
if summary_time?(time) and beacon_summary_node?(subset, time, node_public_key) do
handle_summary(time, subset)
end
end
{:noreply, next_state(state, time)}
end
defp handle_slot(
time,
current_slot = %Slot{subset: subset},
node_public_key
) do
current_slot = ensure_p2p_view(current_slot)
# Avoid to store or dispatch an empty beacon's slot
unless Slot.empty?(current_slot) do
beacon_transaction = create_beacon_transaction(current_slot)
summary_time =
if summary_time?(time) do
time
else
SummaryTimer.next_summary(time)
end
# Local summary node prestore the transaction
if beacon_summary_node?(subset, summary_time, node_public_key) do
chain_address = beacon_summary_address(subset, summary_time)
TransactionChain.write_transaction(beacon_transaction, chain_address)
end
# Before the summary time, we dispatch to other summary nodes the transaction
unless summary_time?(time) do
next_time = SlotTimer.next_slot(time)
broadcast_beacon_transaction(subset, next_time, beacon_transaction, node_public_key)
end
end
end
defp next_state(state = %{subset: subset}, time) do
next_time = SlotTimer.next_slot(time)
Map.put(
state,
:current_slot,
%Slot{subset: subset, slot_time: next_time}
)
end
defp broadcast_beacon_transaction(subset, next_time, transaction, node_public_key) do
%Slot{subset: subset, slot_time: next_time}
|> Slot.involved_nodes()
|> Enum.reject(&(&1.first_public_key == node_public_key))
|> P2P.broadcast_message(%ReplicateTransaction{
transaction: transaction,
welcome_node_public_key: Crypto.last_node_public_key()
})
end
defp handle_summary(time, subset) do
chain_address = beacon_summary_address(subset, time)
case TransactionChain.get(chain_address, data: [:content]) do
[] ->
:ok
beacon_chain ->
beacon_chain
|> create_summary_transaction(subset, time)
|> TransactionChain.write_transaction()
end
end
defp summary_time?(time) do
SummaryTimer.match_interval?(DateTime.truncate(time, :millisecond))
end
defp beacon_summary_address(subset, time) do
Crypto.derive_beacon_chain_address(subset, time, true)
end
defp beacon_slot_node?(subset, slot_time, node_public_key) do
%Slot{subset: subset, slot_time: slot_time}
|> Slot.involved_nodes()
|> Utils.key_in_node_list?(node_public_key)
end
defp beacon_summary_node?(subset, summary_time, node_public_key) do
node_list =
Enum.filter(
P2P.authorized_nodes(),
&(DateTime.compare(&1.authorization_date, summary_time) == :lt)
)
Election.beacon_storage_nodes(
subset,
summary_time,
node_list,
Election.get_storage_constraints()
)
|> Utils.key_in_node_list?(node_public_key)
end
defp add_p2p_view(current_slot = %Slot{subset: subset}) do
p2p_views = P2PSampling.get_p2p_views(P2PSampling.list_nodes_to_sample(subset))
Slot.add_p2p_view(current_slot, p2p_views)
end
defp ensure_p2p_view(slot = %Slot{p2p_view: %{availabilities: <<>>}}) do
add_p2p_view(slot)
end
defp ensure_p2p_view(slot = %Slot{}), do: slot
defp create_beacon_transaction(slot = %Slot{subset: subset, slot_time: slot_time}) do
{prev_pub, prev_pv} = Crypto.derive_beacon_keypair(subset, SlotTimer.previous_slot(slot_time))
{next_pub, _} = Crypto.derive_beacon_keypair(subset, slot_time)
tx =
Transaction.new(
:beacon,
%TransactionData{content: Slot.serialize(slot) |> Utils.wrap_binary()},
prev_pv,
prev_pub,
next_pub
)
previous_address = Transaction.previous_address(tx)
prev_tx =
case TransactionChain.get_transaction(previous_address) do
{:error, :transaction_not_exists} ->
nil
{:ok, prev_tx} ->
prev_tx
end
stamp = create_validation_stamp(tx, prev_tx, slot_time)
%{tx | validation_stamp: stamp}
end
defp create_summary_transaction(beacon_chain, subset, summary_time) do
{prev_pub, prev_pv} = Crypto.derive_beacon_keypair(subset, summary_time)
{pub, _} = Crypto.derive_beacon_keypair(subset, summary_time, true)
previous_slots =
Enum.map(beacon_chain, fn %Transaction{
data: %TransactionData{content: content}
} ->
{slot, _} = Slot.deserialize(content)
slot
end)
tx_content =
%Summary{subset: subset, summary_time: summary_time}
|> Summary.aggregate_slots(previous_slots)
|> Summary.serialize()
tx =
Transaction.new(
:beacon_summary,
%TransactionData{content: tx_content |> Utils.wrap_binary()},
prev_pv,
prev_pub,
pub
)
stamp = create_validation_stamp(tx, Enum.at(beacon_chain, 0), summary_time)
%{tx | validation_stamp: stamp}
end
defp create_validation_stamp(tx = %Transaction{}, prev_tx, time = %DateTime{}) do
poi = [tx, prev_tx] |> Enum.filter(& &1) |> TransactionChain.proof_of_integrity()
%ValidationStamp{
proof_of_work: Crypto.first_node_public_key(),
proof_of_integrity: poi,
proof_of_election: <<0::size(512)>>,
timestamp: time
}
|> ValidationStamp.sign()
end
end
|
lib/zaryn/beacon_chain/subset.ex
| 0.864139 | 0.418905 |
subset.ex
|
starcoder
|
defmodule Day25 do
@moduledoc """
Assembunny code interpreter, with output command
"""
@clk_count_enough 10000
defmodule State do
defstruct pc: 0, a: 0, init_a: 0, b: 0, c: 1, d: 0, clk_last: 1, clk_count: 0, clk_error: false
end
def evaluate_file(path, state \\ %State{}) do
path
|> File.read!
|> evaluate(state)
end
@doc """
Evaluate the given instruction set
"""
def evaluate(str, state \\ %State{}) do
str
|> parse_commands
|> search(state)
end
defp search(instructions, %State{a: a}) do
new_state = %State{a: a, init_a: a}
# IO.puts "Testing a = #{inspect a}"
result = run(instructions, new_state)
if !result.clk_error do
result.init_a
else
search(instructions, %State{new_state | a: new_state.init_a + 1})
end
end
defp run(instructions, state = %State{pc: pc}) do
instruction = Enum.at(instructions, pc)
# IO.puts "Eval: #{inspect instruction}"
new_state = eval(instruction, state)
# IO.inspect new_state
unless new_state.pc >= length(instructions) do
run(instructions, new_state)
else
new_state
end
end
defp eval({:cpy, value, target}, state) when is_atom(value) do
state
|> Map.put(target, Map.get(state, value))
|> update_pc(1)
end
defp eval({:cpy, value, target}, state) when is_integer(value) do
state
|> Map.put(target, value)
|> update_pc(1)
end
defp eval({:inc, target}, state) do
state
|> Map.update!(target, &(&1 + 1))
|> update_pc(1)
end
defp eval({:dec, target}, state) do
state
|> Map.update!(target, &(&1 - 1))
|> update_pc(1)
end
defp eval({:jnz, test, offset}, state) when is_atom(test) do
val = Map.get(state, test)
if 0 == val do
update_pc(state, 1)
else
update_pc(state, offset)
end
end
defp eval({:jnz, test, offset}, state) when is_integer(test) do
if 0 == test do
update_pc(state, 1)
else
update_pc(state, offset)
end
end
defp eval({:out, target}, state) when is_atom(target) do
val = Map.get(state, target)
check_clk(val, state)
end
defp eval({:out, target}, state) when is_integer(target) do
check_clk(target, state)
end
defp check_clk(a, state = %State{clk_last: a}) do
# IO.puts "Matched, got: #{inspect a}, last: #{inspect a}, cnt: #{state.clk_count}"
%State{state | clk_error: true, pc: 99999999}
end
defp check_clk(a, state = %State{clk_last: b, clk_count: cnt}) when a != b and cnt >= @clk_count_enough do
# IO.puts "Got enough chars"
%State{state | clk_error: false, pc: 99999999}
end
defp check_clk(a, state = %State{clk_last: b}) when a != b do
# IO.puts "Ok, got: #{inspect a}, last: #{inspect b}"
new = %State{state | clk_last: a, clk_count: state.clk_count + 1}
update_pc(new, 1)
end
defp update_pc(state, offset) do
Map.update!(state, :pc, &(&1 + offset))
end
defp parse_commands(str) do
str
|> String.trim
|> String.split("\n")
|> Enum.map(&String.trim/1)
|> Enum.map(&convert_command/1)
end
defp convert_command(<<"inc ", rest :: binary>>) do
{:inc, string_to_register(rest)}
end
defp convert_command(<<"dec ", rest :: binary>>) do
{:dec, string_to_register(rest)}
end
defp convert_command(<<"cpy ", rest :: binary>>) do
[value, register] = String.split(rest)
{:cpy, convert_value(value), string_to_register(register)}
end
defp convert_command(<<"jnz ", rest :: binary>>) do
[test, offset] = String.split(rest)
{:jnz, convert_value(test), convert_value(offset)}
end
defp convert_command(<<"out ", rest :: binary>>) do
{:out, convert_value(rest)}
end
defp convert_value(str) do
list = String.to_charlist(str)
if Enum.at(list, 0) >= ?a do
string_to_register(str)
else
String.to_integer(str)
end
end
defp string_to_register(str) do
String.to_atom(str)
end
end
|
day25/lib/day25.ex
| 0.527073 | 0.558086 |
day25.ex
|
starcoder
|
defmodule RDF.XSD.Decimal do
@moduledoc """
`RDF.XSD.Datatype` for XSD decimals.
"""
@type valid_value :: Decimal.t()
use RDF.XSD.Datatype.Primitive,
name: "decimal",
id: RDF.Utils.Bootstrapping.xsd_iri("decimal")
alias RDF.XSD
alias Elixir.Decimal, as: D
def_applicable_facet XSD.Facets.MinInclusive
def_applicable_facet XSD.Facets.MaxInclusive
def_applicable_facet XSD.Facets.MinExclusive
def_applicable_facet XSD.Facets.MaxExclusive
def_applicable_facet XSD.Facets.TotalDigits
def_applicable_facet XSD.Facets.FractionDigits
def_applicable_facet XSD.Facets.Pattern
@doc false
def min_inclusive_conform?(min_inclusive, value, _lexical) do
not (D.cmp(value, D.new(min_inclusive)) == :lt)
end
@doc false
def max_inclusive_conform?(max_inclusive, value, _lexical) do
not (D.cmp(value, D.new(max_inclusive)) == :gt)
end
@doc false
def min_exclusive_conform?(min_exclusive, value, _lexical) do
D.cmp(value, D.new(min_exclusive)) == :gt
end
@doc false
def max_exclusive_conform?(max_exclusive, value, _lexical) do
D.cmp(value, D.new(max_exclusive)) == :lt
end
@doc false
def total_digits_conform?(total_digits, value, _lexical) do
do_digit_count(to_string(value)) <= total_digits
end
@doc false
def fraction_digits_conform?(fraction_digits, value, _lexical) do
do_fraction_digit_count(to_string(value)) <= fraction_digits
end
@doc false
def pattern_conform?(pattern, _value, lexical) do
XSD.Facets.Pattern.conform?(pattern, lexical)
end
@impl XSD.Datatype
def lexical_mapping(lexical, opts) do
if String.contains?(lexical, ~w[e E]) do
@invalid_value
else
case D.parse(lexical) do
{:ok, decimal} -> elixir_mapping(decimal, opts)
:error -> @invalid_value
end
end
end
@impl XSD.Datatype
@spec elixir_mapping(valid_value | integer | float | any, Keyword.t()) :: value
def elixir_mapping(value, _)
def elixir_mapping(%D{coef: coef}, _) when coef in ~w[qNaN sNaN inf]a,
do: @invalid_value
def elixir_mapping(%D{} = decimal, _),
do: canonical_decimal(decimal)
def elixir_mapping(value, opts) when is_integer(value),
do: value |> D.new() |> elixir_mapping(opts)
def elixir_mapping(value, opts) when is_float(value),
do: value |> D.from_float() |> elixir_mapping(opts)
def elixir_mapping(_, _), do: @invalid_value
@doc false
@spec canonical_decimal(valid_value) :: valid_value
def canonical_decimal(decimal)
def canonical_decimal(%D{coef: 0} = decimal),
do: %{decimal | exp: -1}
def canonical_decimal(%D{coef: coef, exp: 0} = decimal),
do: %{decimal | coef: coef * 10, exp: -1}
def canonical_decimal(%D{coef: coef, exp: exp} = decimal)
when exp > 0,
do: canonical_decimal(%{decimal | coef: coef * 10, exp: exp - 1})
def canonical_decimal(%D{coef: coef} = decimal)
when Kernel.rem(coef, 10) != 0,
do: decimal
def canonical_decimal(%D{coef: coef, exp: exp} = decimal),
do: canonical_decimal(%{decimal | coef: Kernel.div(coef, 10), exp: exp + 1})
@impl XSD.Datatype
@spec canonical_mapping(valid_value) :: String.t()
def canonical_mapping(value)
def canonical_mapping(%D{sign: sign, coef: :qNaN}),
do: if(sign == 1, do: "NaN", else: "-NaN")
def canonical_mapping(%D{sign: sign, coef: :sNaN}),
do: if(sign == 1, do: "sNaN", else: "-sNaN")
def canonical_mapping(%D{sign: sign, coef: :inf}),
do: if(sign == 1, do: "Infinity", else: "-Infinity")
def canonical_mapping(%D{} = decimal),
do: D.to_string(decimal, :normal)
@impl RDF.Literal.Datatype
def do_cast(value)
def do_cast(%XSD.String{} = xsd_string) do
xsd_string.value |> new() |> canonical()
end
def do_cast(literal) do
cond do
XSD.Boolean.datatype?(literal) ->
case literal.value do
false -> new(0.0)
true -> new(1.0)
end
XSD.Integer.datatype?(literal) ->
new(literal.value)
# we're catching XSD.Floats with this too
is_float(literal.value) and XSD.Double.datatype?(literal) ->
new(literal.value)
true ->
super(literal)
end
end
@impl RDF.Literal.Datatype
def do_equal_value_same_or_derived_datatypes?(left, right),
do: XSD.Numeric.do_equal_value?(left, right)
@impl RDF.Literal.Datatype
def do_equal_value_different_datatypes?(left, right),
do: XSD.Numeric.do_equal_value?(left, right)
@impl RDF.Literal.Datatype
def do_compare(left, right), do: XSD.Numeric.do_compare(left, right)
@doc """
The number of digits in the XML Schema canonical form of the literal value.
"""
@spec digit_count(RDF.Literal.t()) :: non_neg_integer | nil
def digit_count(literal)
def digit_count(%RDF.Literal{literal: datatype_literal}), do: digit_count(datatype_literal)
def digit_count(%datatype{} = literal) do
cond do
XSD.Integer.datatype?(datatype) ->
XSD.Integer.digit_count(literal)
datatype?(datatype) and datatype.valid?(literal) ->
literal
|> datatype.canonical_lexical()
|> do_digit_count()
true ->
nil
end
end
@doc false
def do_digit_count(decimal_string) do
decimal_string
|> String.replace(".", "")
|> String.replace("-", "")
|> String.length()
end
@doc """
The number of digits to the right of the decimal point in the XML Schema canonical form of the literal value.
"""
@spec fraction_digit_count(RDF.Literal.t()) :: non_neg_integer | nil
def fraction_digit_count(%RDF.Literal{literal: datatype_literal}),
do: fraction_digit_count(datatype_literal)
def fraction_digit_count(%datatype{} = literal) do
cond do
XSD.Integer.datatype?(literal) ->
0
datatype?(literal) and datatype.valid?(literal) ->
literal
|> datatype.canonical_lexical()
|> do_fraction_digit_count()
true ->
nil
end
end
@doc false
def do_fraction_digit_count(decimal_string) do
[_, fraction] = String.split(decimal_string, ".")
String.length(fraction)
end
end
|
lib/rdf/xsd/datatypes/decimal.ex
| 0.886211 | 0.594963 |
decimal.ex
|
starcoder
|
defmodule WaveshareHat.SMS do
@moduledoc """
Includes helper functions for sending and receiving SMS.
"""
import WaveshareHat.Utils
@doc """
Set the number from which SMS message are sent.
"""
def set_local_number(pid, number), do: write(pid, "AT+CSCA=\"#{number}\"")
@doc """
Set the format of SMS messages to Text (1) or PDU (0) mode.
"""
def set_sms_mode(pid, mode) when mode in [0, 1] do
write(pid, "AT+CMGF=#{mode}")
end
@doc """
Set the TE character set to GSM or UCS2.
"""
def set_te_character_set(pid, set) when set in ["GSM", "UCS2"] do
write(pid, "AT+CSCS=#{set}")
end
@doc """
Set the SMS text mode parameters.
The parameters must be a list in the following order: `[fo, vp, pid, dcs]`.
Every value but the `fo`-parameter are optional.
Below is a list of possible parameters and their meaning.
## fo
Depending on the command or result code:
* first octet of GSM 03.40 SMS-DELIVER
* SMS-SUBMIT (default `17`)
* SMS-STATUS-REPORT
* SMS-COMMAND (default `2`) in integer format.
> SMS status report is supported under text mode if `<fo>` is set to `49`.
## vp
Depending on SMS-SUBMIT `<fo>` setting:
GSM 03.40 TP-Validity-Period either in
* integer format (default `167`) or
* in time-string format (refer `<dt>`)
## pid
GSM 03.40 TP-Protocol-Identifier in integer format (default `0`).
## dcs
GSM 03.38 SMS Data Coding Scheme in Integer format.
"""
def set_sms_mode_params(pid, params) when is_list(params) do
write(pid, "AT+CSMP=#{Enum.join(params, ",")}")
end
def set_sms_mode_params(pid, param) when is_integer(param) do
set_sms_mode_params(pid, [param])
end
@doc """
Set the SMS message text body.
Can be used multiple times for multiple lines.
Don't forget to finish the text input with an `end_mark/1`.
"""
def set_sms_body(pid, body) when is_binary(body) do
write(pid, body)
end
@doc """
Reads a SMS message at a given position of the inbox.
"""
def read_sms(pid, position), do: write(pid, "AT+CMGR=#{position}")
@doc """
Sends a previously entered message to a given number.
This is the last command necessary for sending a SMS.
Make sure to write a message before like this:
iex> WaveshareHat.set_local_number(pid, "YOUR_NUMBER")
iex> WaveshareHat.set_sms_body(pid, "Hello there, friend!")
iex> WaveshareHat.set_receiver(pid, "YOUR_FRIENDS_NUMBER")
iex> WaveshareHat.end_mark(pid)
"""
def set_receiver(pid, to_number), do: write(pid, "AT+CMGS=\"#{to_number}\"")
# Configuration
@doc """
Set the ATE echo mode On (1) or Off (0).
"""
def set_echo_mode(pid, mode) when mode in [0, 1] do
write(pid, "ATE#{mode}")
end
@doc """
Enable (1) or disable (0) COLP notifications.
"""
def set_colp_notification(pid, status) when status in [0, 1] do
write(pid, "AT+COLP=#{status}")
end
@doc """
Set the SMS text mode parameters.
The parameters must be a list in the following order: `[mode, mt, bm, ds, bfr]`.
Every value but the `mode`-parameter are optional.
Below is a list of possible parameters and their meaning.
## Mode
* `0` - Buffer unsolicited result codes in the TA. If TA result
code buffer is full, indications can be buffered in some other place or the
oldest indications may be discarded and replaced with the new received
indications.
* `1` - Discard indication and reject new received message
unsolicited result codes when TA-TE link is reserved (e.g. in on-line data
mode). Otherwise forward them directly to the TE.
* `2` - Buffer unsolicited result codes in the TA when TA-TE
link is reserved (e.g. in on-line data mode) and flush them to the TE after
reservation. Otherwise forward them directly to the TE.
* `3` - Forward unsolicited result codes directly to the TE.
TA-TE link specific inband technique used to embed result codes and data
when TA is in on-line data mode.
## mt
* `0` - No SMS-DELIVER indications are routed to the TE.
* `1` - If SMS-DELIVER is stored into ME/TA, indication of the memory location
is routed to the TE using unsolicited result code: `+CMTI: <mem>,<index>`
* `2` - SMS-DELIVERs (except class 2) are routed directly to the TE using unsolicited result code:
`+CMT: [<alpha>],<length><CR><LF><pdu>` (PDU mode enabled) or
`+CMT: <oa>,[<alpha>],<scts> [,<tooa>,<fo>,<pid>,<dcs>,<sca>,<tosca>,<length>]<CR><LF><data>`
Class 2 messages result in indication as defined in <mt>=1.
* `3` - Class 3 SMS-DELIVERs are routed directly to TE using unsolicited result codes defined in `<mt>=2`.
Messages of other classes result in indication as defined in `<mt>=1`.
## bm
> The rules for storing received CBMs depend on its data coding scheme (refer GSM 03.38 [2]), the setting of Select CBM Types (+CSCB) and this value:
* `0` - No CBM indications are routed to the TE.
* `2` - New CBMs are routed directly to the TE using unsolicited result code:
`+CBM: <length><CR><LF><pdu>` (PDU mode enabled) or
`+CBM: <sn>,<mid>,<dcs>,<page>,<pages><CR><LF><data>` (text mode enabled).
## ds
* `0` - No SMS-STATUS-REPORTs are routed to the TE.
* `1` - SMS-STATUS-REPORTs are routed to the TE using unsolicited result code:
`+CDS:<length><CR><LF><pdu>` (PDU mode enabled) or
`+CDS: <fo>,<mr>[,<ra>][,<tora>],<scts>,<dt>,<st>` (text mode enabled)
## bfr
* `0` - TA buffer of unsolicited result codes defined within this Command is flushed to the TE when `<mode> 1...3` is entered (OK response shall be given before flushing the codes).
* `1` - TA buffer of unsolicited result codes defined within this command is cleared when `<mode> 1...3` is entered
"""
def set_new_sms_indicator(pid, modes) when is_list(modes) do
write(pid, "AT+CNMI=#{Enum.join(modes, ",")}")
end
def set_new_sms_indicator(pid, mode) when is_integer(mode) do
set_new_sms_indicator(pid, [mode])
end
end
|
lib/waveshare/sms.ex
| 0.792906 | 0.5144 |
sms.ex
|
starcoder
|
defmodule Ockam.Session.Handshake do
@moduledoc """
Session handshake behaviour.
Used in `Ockam.Session.Pluggable` and `Ockam.Session.Separate` modules
"""
@type message() :: Ockam.Message.t()
@typedoc """
State passed to the callbacks, can be modified, but following fields are required:
`init_route` - (initiator only) session initial route to send initial handshake to
`worker_address` - inner address of the data worker
`handshake_address` - inner address of the handshake worker
For pluggable session, `worker_address` and `handshake_address` are the same
"""
@type handshake_state() :: %{
:init_route => Ockam.Address.route(),
:worker_address => Ockam.Address.t(),
:handshake_address => Ockam.Address.t(),
any() => any()
}
@doc """
Create initial handshake message using handshake options and state
Called by session initiator
"""
@callback init(options :: Keyword.t(), handshake_state()) ::
{:next, message(), handshake_state()} | {:error, any()}
## TODO: error result
@doc """
Handle handshake message on session initiator
Arguments:
`handshake_options` - options set in `handshake_options` for session worker
`message` - handshake message received
`handshake_state` - additional worker state, see type `handshake_state/0`
Returns:
`{:next, handshake_state()}` - wait for the next handshake message
`{:next, message, handshake_state()}` - send a handshake message and wait for next one
`{:ready, options, handshake_state()}` - start data worker with options and switch to data mode
`{:ready, message, options, handshake_state()}` - start data worker and send handshake message
"""
@callback handle_initiator(
handshake_options :: Keyword.t(),
message(),
handshake_state()
) ::
{:next, handshake_state()}
| {:next, message(), handshake_state()}
| {:ready, worker_options :: Keyword.t(), handshake_state()}
| {:ready, message(), worker_options :: Keyword.t(), handshake_state()}
@doc """
Handle handshake on session responder
see `handle_initiator/3`
"""
@callback handle_responder(
handshake_options :: Keyword.t(),
message :: message(),
state :: handshake_state()
) ::
{:next, handshake_state()}
| {:next, message(), handshake_state()}
| {:ready, worker_options :: Keyword.t(), handshake_state()}
| {:ready, message(), worker_options :: Keyword.t(), handshake_state()}
end
|
implementations/elixir/ockam/ockam/lib/ockam/session/handshake.ex
| 0.773901 | 0.452173 |
handshake.ex
|
starcoder
|
defmodule BNO055 do
use BNO055.SensorInterface
@moduledoc """
This module is used to create commands for interacting with a Bosch BNO055 sensor. This
module is intended to be an unopinionated collection of functions to created data for
communicating with the sensor, but does not handle actual communication.
Set functions return tuple with address and data to be written to that address
```elixir
iex> BNO055.set_mode(:config)
{0x3D, <<0x00>>}
```
Get functions return tuple with address and number of bytes to read
```elixir
iex> BNO055.get_chip_address
{0x00, 1}
```
`write` functions take the get or set results and return a binary for writing to the
device based on the protocol type
iex> BNO055.set_mode(:config) |> BNO055.IO.I2c.write_data
{:write, <<0x3D, 0x00>>}
iex> BNO055.set_mode(:config) |> BNO055.IO.Serial.write_data
<<0xAA, 0x00, 0x3D, 0x01, 0x00>>
Decode functions take the data returned from get functions and returns formatted results
"""
@type register_address :: 0..0x6A
@type set_result :: {register_address, binary}
@type get_result :: {register_address, pos_integer}
@type operational_modes :: :config | :acconly | :magonly | :gyroonly | :accmag |
:accgyro | :maggyro | :amg | :imu | :compass | :m4g | :ndof_fmc_off | :ndof
@type power_mode :: :normal | :lowpower | :suspend
@type axis_remap :: :x_axis|:y_axis|:z_axis
@type axis_sign :: :positive | :negative
@doc """
Sets the operational mode of the BNO055 sensor.
## Valid Modes:
- :config - Used to configure the sensor
** Non-fusion modes **
- :acconly - Only accelerometer sensor on
- :magonly - Only magnetometer sensor on
- :gyroonly - Only gyroscope sensor on
- :accmag - Both accelerometer & magnetometer sensors on
- :accgyro - Both accelerometer & gyroscope sensors on
- :maggyro - Both magnetometer & gyroscope sensors on
- :amg - All three sensors on, but no fusion data generated
** Fusion modes **
- :imu - the relative orientation of the BNO055 in space is calculated from the accelerometer and gyroscope data. The calculation is fast (i.e. high output data rate)
- :compass - th absolute orientation of the BNO055 is given. (requires calibration. see datasheet)
- :m4g - Magnet for Gyroscope - similar to IMU, but uses magnetometer to detect rotation
- :ndof_fmc_off - same as NDOF, but with Fast Magnetometer Calibration turned off
- :ndof - Fusion mode with 9 degrees of freedom where the fused absolute orientation data is calculate from all three sensors.
See section 3.3 of the datasheet for more detailed information
on the operational modes.
"""
@spec set_mode(operational_modes) :: set_result
def set_mode(:config), do: {@opr_mode_addr, <<0x00>>}
def set_mode(:acconly), do: {@opr_mode_addr, <<0x01>>}
def set_mode(:magonly), do: {@opr_mode_addr, <<0x02>>}
def set_mode(:gyroonly), do: {@opr_mode_addr, <<0x03>>}
def set_mode(:accmag), do: {@opr_mode_addr, <<0x04>>}
def set_mode(:accgyro), do: {@opr_mode_addr, <<0x05>>}
def set_mode(:maggyro), do: {@opr_mode_addr, <<0x06>>}
def set_mode(:amg), do: {@opr_mode_addr, <<0x07>>}
def set_mode(:imu), do: {@opr_mode_addr, <<0x08>>}
def set_mode(:compass), do: {@opr_mode_addr, <<0x09>>}
def set_mode(:m4g), do: {@opr_mode_addr, <<0x0A>>}
def set_mode(:ndof_fmc_off), do: {@opr_mode_addr, <<0x0B>>}
def set_mode(:ndof), do: {@opr_mode_addr, <<0x0C>>}
def set_mode(inv_mode), do: raise ArgumentError, "Invalid mode #{inv_mode} given!"
@doc """
Sets if an external crystal is attached to the sensor.
** Sensor must be in config mode before receiving this command
"""
@spec set_external_crystal(true|false) :: set_result
def set_external_crystal(true), do: {@sys_trigger_addr, <<0x80>>}
def set_external_crystal(false), do: {@sys_trigger_addr, <<0x00>>}
@doc """
Set the sensor calibration offsets by sending previously generated
calibration data received from `get_calibration/0` or decoded map
from calibration data.
```
%{
accel: %{
x: acc_x,
y: acc_y,
z: acc_z,
radius: acc_radius
},
mag: %{
x: mag_x,
y: mag_y,
z: mag_z,
radius: mag_radius
},
gyro: %{
x: gyro_x,
y: gyro_y,
z: gyro_z
}
}
```
See section 3.6.4 of datasheet for detailed information about the valid
values for sensor configuration.
"""
@spec set_calibration(binary) :: set_result
def set_calibration(data) when is_binary(data) and byte_size(data) == 22 do
{@accel_offset_x_lsb_addr, data}
end
def set_calibration(%{accel: %{x: acc_x, y: acc_y, z: acc_z, radius: acc_radius}, mag: %{x: mag_x, y: mag_y, z: mag_z, radius: mag_radius}, gyro: %{x: gyro_x, y: gyro_y, z: gyro_z}}) do
{@accel_offset_x_lsb_addr, <<
acc_x :: size(16)-signed-little,
acc_y :: size(16)-signed-little,
acc_z :: size(16)-signed-little,
mag_x :: size(16)-signed-little,
mag_y :: size(16)-signed-little,
mag_z :: size(16)-signed-little,
gyro_x :: size(16)-signed-little,
gyro_y :: size(16)-signed-little,
gyro_z :: size(16)-signed-little,
acc_radius :: size(16)-signed-little,
mag_radius :: size(16)-signed-little
>>}
end
@doc """
Sets the power mode of the BNO055.
## Valid Modes
- :normal - All sensors for selected operational mode are turned on
- :lowpower - If no motion is detected for a set period of time (default 5 seconds), then then BNO055 enters a low power mode where only the accelerometer is active.
- :suspend - All sensors and microcontroller are put into sleep mode.
See section 3.2 of datasheet for more detailed information on power modes.
"""
@spec set_power_mode(power_mode) :: set_result
def set_power_mode(:normal), do: {@pwr_mode_addr, <<0x00>>}
def set_power_mode(:lowpower), do: {@pwr_mode_addr, <<0x01>>}
def set_power_mode(:suspend), do: {@pwr_mode_addr, <<0x02>>}
def set_power_mode(inv_mode), do: raise ArgumentError, "Invalid power mode #{inv_mode} given!"
@doc """
Sets the current register page for the BNO055. Valid pages are 0 or 1
"""
@spec set_page(0|1) :: set_result
def set_page(0), do: {@page_id_addr, <<0>>}
def set_page(1), do: {@page_id_addr, <<1>>}
def set_page(inv_page), do: raise ArgumentError, "Invalid page #{inv_page} given!"
@doc """
Sets the outputed units for orientation mode, temperature, euler angles, gyroscope,
acceleration.
## Orientation Mode
:windows
:android
## Temperature
:celsius
:fahrenheit
## Euler Angles
:degrees
:radians
## Gyroscope angular rate units
:dps
:rps
## Accleration units
:ms2
:mg
See section 3.6.1 of the datasheet for more details on output units
"""
@spec set_output_units(:windows|:android, :celsius|:fahrenheit, :degrees|:radians, :dps|:rps, :ms2|:mg) :: set_result
def set_output_units(orientation, temp, euler, gyro, acc) do
orientation_val = case orientation do
:windows -> 0
:android -> 1
_ -> raise ArgumentError, "Invalid orientation mode #{orientation} given!"
end
temp_val = case temp do
:celsius -> 0
:fahrenheit -> 1
_ -> raise ArgumentError, "Invalid temperature units #{temp} given!"
end
euler_val = case euler do
:degrees -> 0
:radians -> 1
_ -> raise ArgumentError, "Invalid euler units #{euler} given!"
end
gyro_val = case gyro do
:dps -> 0
:rps -> 1
_ -> raise ArgumentError, "Invalid gyro #{gyro} given!"
end
acc_val = case acc do
:ms2 -> 0
:mg -> 1
_ -> raise ArgumentError, "Invalid acceleration units #{acc} given!"
end
{
@unit_sel_addr,
<<
orientation_val::size(1),
0::size(2),
temp_val::size(1),
0::size(1),
euler_val::size(1),
gyro_val::size(1),
acc_val::size(1)
>>
}
end
@doc """
Sets the axis remap for each of the 3 axis, as well as the sign for each axis as :positive or :negative (inverted)
Valid axis remap values - :x_axis, :y_axis, :z_axis
Valid axis sign values - :positive, :negative
Note two axises cannot be mapped to the same axis remap value.
See section 3.4 of the datasheet for more information.
"""
@spec set_axis_mapping(axis_remap, axis_remap, axis_remap, axis_sign, axis_sign, axis_sign) :: set_result
def set_axis_mapping(x, y, z, x_sign, y_sign, z_sign) do
x_val = case x do
:x_axis -> 0
:y_axis -> 1
:z_axis -> 2
_ -> raise ArgumentError, "Invalid x axis mapping x: #{x} given!"
end
y_val = case y do
:x_axis -> 0
:y_axis -> 1
:z_axis -> 2
_ -> raise ArgumentError, "Invalid y axis mapping y: #{y} given!"
end
z_val = case z do
:x_axis -> 0
:y_axis -> 1
:z_axis -> 2
_ -> raise ArgumentError, "Invalid z axis mapping z: #{z} given!"
end
case {x,y,z} do
{_, ^x, _} -> raise ArgumentError, "Invalid axis mappings given, axis mappings must be mutually exclusive. x == y"
{_, _, ^x} -> raise ArgumentError, "Invalid axis mappings given, axis mappings must be mutually exclusive. x == z"
{_, _, ^y} -> raise ArgumentError, "Invalid axis mappings given, axis mappings must be mutually exclusive. y == z"
_ -> true
end
x_sign_val = case x_sign do
:positive -> 0
:negative -> 1
_ -> raise ArgumentError, "Invalid x axis sign mapping #{x_sign} given!"
end
y_sign_val = case y_sign do
:positive -> 0
:negative -> 1
_ -> raise ArgumentError, "Invalid y axis sign mapping #{y_sign} given!"
end
z_sign_val = case z_sign do
:positive -> 0
:negative -> 1
_ -> raise ArgumentError, "Invalid z axis sign mapping #{z_sign} given!"
end
data = <<
0 :: size(2),
z_val :: size(2),
y_val :: size(2),
x_val :: size(2),
0 :: size(5),
x_sign_val :: size(1),
y_sign_val :: size(1),
z_sign_val :: size(1)
>>
{@axis_map_config_addr, data}
end
@spec set_axis_mapping(map) :: set_result
def set_axis_mapping(%{x_axis: x, y_axis: y, z_axis: z, x_sign: x_sign, y_sign: y_sign, z_sign: z_sign}) do
set_axis_mapping(
x,
y,
z,
x_sign,
y_sign,
z_sign
)
end
@doc """
BNO055 is reset, rebooting microcontroller and clearing current configuration.
The Sensor will be unavailable while reseting and your app should sleep before executing
the next command.
"""
@spec reset() :: set_result
def reset(), do: {@sys_trigger_addr, <<0x20>>}
@doc """
Resets the system trigger back to 0x00. All bits off.
"""
@spec reset_system_trigger() :: set_result
def reset_system_trigger(), do: {@sys_trigger_addr, <<0x00 :: size(8)>>}
@doc """
Command to get the sensor chip address
"""
@spec get_chip_address() :: get_result
def get_chip_address, do: {@chip_id_addr, 1}
@doc """
Command to get system status
"""
@spec get_system_status() :: get_result
def get_system_status, do: {@sys_stat_addr, 1}
@doc """
Command to get last sensor self test result
"""
@spec get_self_test_result() :: get_result
def get_self_test_result, do: {@selftest_result_addr, 1}
@doc """
Command to get system error data
"""
@spec get_system_error_data() :: get_result
def get_system_error_data, do: {@sys_err_addr, 1}
@doc """
Command to get sensor revision infomation
"""
@spec get_revision_info() :: get_result
def get_revision_info, do: {@accel_rev_id_addr, 6}
@doc """
Command to get calibration status
"""
@spec get_calibration_status() :: get_result
def get_calibration_status, do: {@calib_stat_addr, 1}
@doc """
Command to get sensor calibration data
"""
@spec get_calibration() :: get_result
def get_calibration, do: {@accel_offset_x_lsb_addr, 22}
@doc """
Command to get sensor axis remapping
"""
@spec get_axis_mapping() :: get_result
def get_axis_mapping, do: {@axis_map_config_addr, 2}
@doc """
Command to read latest euler angles from fusion mode
"""
@spec get_euler_reading() :: get_result
def get_euler_reading, do: {@euler_h_lsb_addr, 6}
@doc """
Command to read latest magnetometer values
"""
@spec get_magnetometer_reading() :: get_result
def get_magnetometer_reading, do: {@mag_data_x_lsb_addr, 6}
@doc """
Command to read latest gyroscope values
"""
@spec get_gyroscope_reading() :: get_result
def get_gyroscope_reading, do: {@gyro_data_x_lsb_addr, 6}
@doc """
Command to read latest accelerometer values
"""
@spec get_accelerometer_reading() :: get_result
def get_accelerometer_reading, do: {@accel_data_x_lsb_addr, 6}
@doc """
Command to read latest linear acceleration values
"""
@spec get_linear_acceleration_reading() :: get_result
def get_linear_acceleration_reading, do: {@linear_accel_data_x_lsb_addr, 6}
@doc """
Command to read latest gravity values
"""
@spec get_gravity_reading() :: get_result
def get_gravity_reading, do: {@gravity_data_x_lsb_addr, 6}
@doc """
Command to read latest quaternion values
"""
@spec get_quaternion_reading() :: get_result
def get_quaternion_reading, do: {@quaternion_data_w_lsb_addr, 8}
@doc """
Command to read latest temperature value
"""
@spec get_temperature_reading() :: get_result
def get_temperature_reading, do: {@temp_addr, 1}
@doc """
Takes binary data returned from sensor system status and returns decoded string
"""
@spec decode_system_status(binary) :: String.t
def decode_system_status(data) when is_binary(data) do
case data do
<<0>> -> "Idle"
<<1>> -> "System Error"
<<2>> -> "Initializing Peripherals"
<<3>> -> "System Iniitalization"
<<4>> -> "Executing Self-Test"
<<5>> -> "Sensor fusion algorithm running"
<<6>> -> "System running without fusion algorithms"
_ -> "Unknown status: #{data}"
end
end
@doc """
Takes binary data returned from sensor self test and returns decoded data in a map
%{
mcu: "Pass",
gyro: "Pass",
mag: "Fail",
accel: "Fail"
}
"""
@spec decode_self_test_result(binary) :: map
def decode_self_test_result(data) when is_binary(data) do
<<
_ :: size(4),
mcu_st :: size(1),
gyro_st :: size(1),
mag_st :: size(1),
acc_st :: size(1)
>> = data
%{
mcu: (if mcu_st == 1, do: "Pass", else: "Fail"),
gyro: (if gyro_st == 1, do: "Pass", else: "Fail"),
mag: (if mag_st == 1, do: "Pass", else: "Fail"),
accel: (if acc_st == 1, do: "Pass", else: "Fail")
}
end
@doc """
Takes binary data returned from sensor error data and returns decoded string
"""
@spec decode_system_error_data(binary) :: String.t
def decode_system_error_data(data) when is_binary(data) do
case data do
<<0x00>> -> "No error"
<<0x01>> -> "Peripheral initialization error"
<<0x02>> -> "System initialization error"
<<0x03>> -> "Self test result failed"
<<0x04>> -> "Register map value out of range"
<<0x05>> -> "Register map address out of range"
<<0x06>> -> "Register map write error"
<<0x07>> -> "BNO low power mode not available for selected operation mode"
<<0x08>> -> "Accelerometer power mode not available"
<<0x09>> -> "Fusion algorithm configuration error"
<<0x0A>> -> "Sensor configuration error"
_ -> "Unknown system error value: #{data}"
end
end
@doc """
Takes binary data returned from sensor revision info and returns decoded map
%{
accel: 0,
mag: 0,
gyro: 0,
bl: 0,
sw: 0
}
"""
@spec decode_revision_info(binary) :: map
def decode_revision_info(data) when is_binary(data) do
<<
accel_rev::size(8),
mag_rev::size(8),
gyro_rev::size(8),
sw_rev::size(16),
bl_rev::size(8)
>> = data
%{
accel: accel_rev,
mag: mag_rev,
gyro: gyro_rev,
bl: bl_rev,
sw: sw_rev
}
end
@doc """
Takes binary data returned from sensor calibration status and returns decoded map
%{
system: :not_calibrated,
gyro: :fully_calibrated,
accel: :fully_calibrated,
mag: :not_calibrated
}
"""
@spec decode_calibration_status(binary) :: map
def decode_calibration_status(data) do
<<
sys_stat::size(2),
gyr_stat::size(2),
acc_stat::size(2),
mag_stat::size(2)
>> = data
%{
system: (if (sys_stat == 3), do: :fully_calibrated, else: :not_calibrated),
gyro: (if (gyr_stat == 3), do: :fully_calibrated, else: :not_calibrated),
accel: (if (acc_stat == 3), do: :fully_calibrated, else: :not_calibrated),
mag: (if (mag_stat == 3), do: :fully_calibrated, else: :not_calibrated)
}
end
@doc """
Takes binary data returned from sensor calibration and returns decoded map
%{
%{
accel: %{
x: 0,
y: 0,
z: 0,
radius: 0
},
mag: %{
x: 0,
y: 0,
z: 0,
radius: 0
},
gyro: %{
x: 0,
y: 0,
z: 0
}
}
}
"""
@spec decode_calibration(binary) :: map
def decode_calibration(data) when is_binary(data) and byte_size(data) == 22 do
<<
acc_x :: size(16)-signed-little,
acc_y :: size(16)-signed-little,
acc_z :: size(16)-signed-little,
mag_x :: size(16)-signed-little,
mag_y :: size(16)-signed-little,
mag_z :: size(16)-signed-little,
gyro_x :: size(16)-signed-little,
gyro_y :: size(16)-signed-little,
gyro_z :: size(16)-signed-little,
acc_radius :: size(16)-signed-little,
mag_radius :: size(16)-signed-little
>> = data
%{
accel: %{
x: acc_x,
y: acc_y,
z: acc_z,
radius: acc_radius
},
mag: %{
x: mag_x,
y: mag_y,
z: mag_z,
radius: mag_radius
},
gyro: %{
x: gyro_x,
y: gyro_y,
z: gyro_z
}
}
end
@doc """
Takes binary data returned from sensor axis remapping and returns decoded map
%{
x_axis: :x_axis,
y_axis: :y_axis,
z_axis: :z_axis,
x_sign: :positive,
y_sign: :negative,
z_sign: :positive
}
"""
@spec decode_axis_mapping(binary) :: map
def decode_axis_mapping(data) when is_binary(data) do
<<
_ :: size(2),
z :: size(2),
y :: size(2),
x :: size(2),
_ :: size(5),
x_sign :: size(1),
y_sign :: size(1),
z_sign :: size(1)
>> = data
%{
x_axis: get_axis_mapping_from_val(x),
y_axis: get_axis_mapping_from_val(y),
z_axis: get_axis_mapping_from_val(z),
x_sign: get_axis_sign_from_val(x_sign),
y_sign: get_axis_sign_from_val(y_sign),
z_sign: get_axis_sign_from_val(z_sign)
}
end
defp get_axis_mapping_from_val(0), do: :x_axis
defp get_axis_mapping_from_val(1), do: :y_axis
defp get_axis_mapping_from_val(2), do: :z_axis
defp get_axis_sign_from_val(0), do: :positive
defp get_axis_sign_from_val(1), do: :negative
@degrees_factor 16.0
@radians_factor 900.0
@ms2_factor 100.0
@mg_factor 1.0
@doc """
Decodes the absolute orientation as a map with heading, roll and pitch angles. Supports both
degrees and radians, default is degrees.
"""
@spec decode_euler_reading(binary, :degrees|:radians) :: map | :no_data
def decode_euler_reading(data, units \\ :degrees)
def decode_euler_reading(<<>>, _), do: :no_data
def decode_euler_reading(data, :degrees), do: _decode_euler(data, @degrees_factor)
def decode_euler_reading(data, :radians), do: _decode_euler(data, @radians_factor)
defp _decode_euler(data, unit_factor) do
<<
heading_rdg :: size(16)-signed-little,
roll_rdg :: size(16)-signed-little,
pitch_rdg :: size(16)-signed-little
>> = data
heading = heading_rdg / unit_factor
roll = roll_rdg / unit_factor
pitch = pitch_rdg / unit_factor
%{
heading: heading,
roll: roll,
pitch: pitch,
}
end
@doc """
Decodes the magnetometer reading returning a map of the current values for each
axis in micro-Teslas
"""
@spec decode_magnetometer_reading(binary) :: map | :no_data
def decode_magnetometer_reading(<<>>), do: :no_data
def decode_magnetometer_reading(data), do: _decode_vector(data, @degrees_factor)
@doc """
Decodes the gyroscope (angular velocity) reading returning a map of the current values for each
axis in either degrees per second or radians per second. Default is degrees per second.
"""
@spec decode_gyroscope_reading(binary, :dps|:rps) :: map | :no_data
def decode_gyroscope_reading(data, units \\ :dps)
def decode_gyroscope_reading(<<>>, _), do: :no_data
def decode_gyroscope_reading(data, :dps), do: _decode_vector(data, @degrees_factor)
def decode_gyroscope_reading(data, :rps), do: _decode_vector(data, @radians_factor)
@doc """
Decodes the accelerometer reading returning a map of the current values for each
axis in meters/second^2 or milli-g. Default is meters/second^2
"""
@spec decode_accelerometer_reading(binary, :ms2|:mg) :: map | :no_data
def decode_accelerometer_reading(data, units \\ :ms2)
def decode_accelerometer_reading(<<>>, _), do: :no_data
def decode_accelerometer_reading(data, :ms2), do: _decode_vector(data, @ms2_factor)
def decode_accelerometer_reading(data, :mg), do: _decode_vector(data, @mg_factor)
@doc """
Decodes the linear acceleration (acceleration from movement, not from gravity) reading
returning a map of the current values for each axis in meters/second^2 or milli-g.
Default is meters/second^2
"""
@spec decode_linear_acceleration_reading(binary, :ms2|:mg) :: map | :no_data
def decode_linear_acceleration_reading(data, units \\ :ms2)
def decode_linear_acceleration_reading(<<>>, _), do: :no_data
def decode_linear_acceleration_reading(data, :ms2), do: _decode_vector(data, @ms2_factor)
def decode_linear_acceleration_reading(data, :mg), do: _decode_vector(data, @mg_factor)
@doc """
Decodes the gravity acceleration reading returning a map of the current values for each
axis in meters/second^2 or milli-g. Default is meters/second^2
"""
@spec decode_gravity_reading(binary, :ms2|:mg) :: map | :no_data
def decode_gravity_reading(data, units \\ :ms2)
def decode_gravity_reading(<<>>, _), do: :no_data
def decode_gravity_reading(data, :ms2), do: _decode_vector(data, @ms2_factor)
def decode_gravity_reading(data, :mg), do: _decode_vector(data, @mg_factor)
@quaternion_scale (1.0 / :math.pow(2, 14))
@doc """
Decodes the orientation returning a map of the X, Y, Z, & W quaternion values
"""
@spec decode_quaternion_reading(binary) :: map | :no_data
def decode_quaternion_reading(<<>>), do: :no_data
def decode_quaternion_reading(data) do
<<
w_raw :: size(16)-signed-little,
x_raw :: size(16)-signed-little,
y_raw :: size(16)-signed-little,
z_raw :: size(16)-signed-little
>> = data
x_val = x_raw * @quaternion_scale
y_val = y_raw * @quaternion_scale
z_val = z_raw * @quaternion_scale
w_val = w_raw * @quaternion_scale
%{
x: x_val,
y: y_val,
z: z_val,
w: w_val
}
end
defp _decode_vector(data, unit_factor) do
<<
x_raw :: size(16)-signed-little,
y_raw :: size(16)-signed-little,
z_raw :: size(16)-signed-little
>> = data
x_val = x_raw / unit_factor
y_val = y_raw / unit_factor
z_val = z_raw / unit_factor
%{
x: x_val,
y: y_val,
z: z_val
}
end
end
|
lib/bno055.ex
| 0.928384 | 0.872836 |
bno055.ex
|
starcoder
|
defmodule CSSEx.RGBA do
@moduledoc """
Struct and helper functions for generating RGBA values.
"""
@colors CSSEx.Helpers.Colors.colors_tuples()
alias CSSEx.Unit
defstruct r: 0, g: 0, b: 0, a: 1
@type t() :: %CSSEx.RGBA{
r: non_neg_integer,
g: non_neg_integer,
b: non_neg_integer,
a: non_neg_integer
}
@doc """
Accepts any value in the form of a binary `"hsla(0, 10%, 20%, 0.5)"` or `"hsl(0, 10%, 20%)"`, any hexadecimal representation in binary in the form of `"#xxx"`, `"#xxxx"`, `"#xxxxxx"` or `"#xxxxxxxx"`, rgb/a as `"rgba(100,100,100,0.1)"` or `"rgb(10,20,30)"`, or any literal color name defined as web colors (CSSEx.Colors) - returns a `%CSSEx.HSLA{}` struct.
"""
def new_rgba(<<"rgba", values::binary>>) do
case Regex.run(~r/\((.+),(.+),(.+),(.+)\)/, values) do
[_, r, g, b, a] ->
new(
String.trim(r),
String.trim(g),
String.trim(b),
String.trim(a)
)
_ ->
{:error, :invalid}
end
end
def new_rgba(<<"rgb", values::binary>>) do
case Regex.run(~r/\((.+),(.+),(.+)\)/, values) do
[_, r, g, b] ->
new(
String.trim(r),
String.trim(g),
String.trim(b),
"1"
)
_ ->
{:error, :invalid}
end
end
def new_rgba(<<"hsla", _::binary>> = full) do
case CSSEx.HSLA.new_hsla(full) do
{:ok, %CSSEx.HSLA{} = hsla} -> from_hsla(hsla)
error -> error
end
end
def new_rgba(<<"hsl", _::binary>> = full) do
case CSSEx.HSLA.new_hsla(full) do
{:ok, %CSSEx.HSLA{} = hsla} -> from_hsla(hsla)
error -> error
end
end
def new_rgba(<<"#", hex::binary>>) do
case hex do
<<r::binary-size(2), g::binary-size(2), b::binary-size(2), a::binary-size(2)>> ->
new(r, g, b, a, 16)
<<r::binary-size(2), g::binary-size(2), b::binary-size(2)>> ->
new(r, g, b, "100", 16)
<<r::binary-size(1), g::binary-size(1), b::binary-size(1), a::binary-size(1)>> ->
new(r, g, b, a, 16)
<<r::binary-size(1), g::binary-size(1), b::binary-size(1)>> ->
new(r, g, b, "100", 16)
_ ->
{:error, :invalid}
end
end
Enum.each(@colors, fn [color, rgba] ->
def new_rgba(unquote(color)), do: new_rgba(unquote(rgba))
end)
@doc """
Converts an existing `%CSSEx.HSLA{}` struct into a `%CSSEx.RGBA{}` struct.
Taken from https://www.niwa.nu/2013/05/math-behind-colorspace-conversions-rgb-hsl
"""
def from_hsla(%CSSEx.HSLA{s: %Unit{value: 0}, l: %Unit{value: l}, a: a}) do
gray = l / 100 * 255
{:ok, %CSSEx.RGBA{r: gray, g: gray, b: gray, a: a}}
end
def from_hsla(%CSSEx.HSLA{h: %Unit{value: h}, s: %Unit{value: s}, l: %Unit{value: l}, a: a}) do
n_l = (l / 100) |> Float.round(3)
n_s = (s / 100) |> Float.round(3)
convert_val_1 =
case n_l >= 0.5 do
true -> n_l + n_s - n_l * n_s
_ -> n_l * (1 + n_s)
end
|> Float.round(3)
convert_val_2 = (2 * n_l - convert_val_1) |> Float.round(3)
hue_norm = (h / 360) |> Float.round(3)
r = hue_norm + 0.333
r_1 = if(r >= 0, do: if(r > 1, do: r - 1, else: r), else: r + 1)
g = hue_norm
g_1 = if(g >= 0, do: if(g > 1, do: g - 1, else: g), else: g + 1)
b = hue_norm - 0.333
b_1 = if(b >= 0, do: if(b > 1, do: b - 1, else: b), else: b + 1)
red = convert_color_chan(convert_val_1, convert_val_2, r_1) * 255
green = convert_color_chan(convert_val_1, convert_val_2, g_1) * 255
blue = convert_color_chan(convert_val_1, convert_val_2, b_1) * 255
{:ok,
%__MODULE__{
r: round(red),
g: round(green),
b: round(blue),
a: a
}}
end
@doc """
Generates a `%CSSEx.RGBA{}` wrapped in an :ok tuple, from the values of r, g, b, and alpha. All values are treated as decimal by default but another base can be provided as an optional argument.
"""
def new(r, g, b, a, base \\ 10),
do: {
:ok,
%__MODULE__{
r: color_value(r, base),
g: color_value(g, base),
b: color_value(b, base),
a: alpha_value(a, base)
}
}
@doc false
def color_value(val, base) when is_binary(val) do
case Integer.parse(val, base) do
{parsed, _} -> valid_rgb_val(parsed)
:error -> 0
end
end
@doc false
def alpha_value(val, 10) do
case Float.parse(val) do
{parsed, _} -> valid_alpha_val(parsed)
:error -> 1
end
end
def alpha_value(val, 16) do
case Integer.parse(val, 16) do
{parsed, _} -> valid_alpha_val(parsed / 256)
:error -> 1
end
end
@doc false
def valid_rgb_val(n) when n <= 255 and n >= 0, do: n
def valid_rgb_val(n) when n > 255, do: 255
def valid_rgb_val(n) when n < 0, do: 0
@doc false
def valid_alpha_val(n) when n > 0 and n <= 1, do: n
def valid_alpha_val(_n), do: 1
@doc false
def convert_color_chan(pass_1, pass_2, temp_color) do
case {6 * temp_color < 1, 2 * temp_color < 1, 3 * temp_color < 2} do
{true, _, _} -> pass_2 + (pass_1 - pass_2) * 6 * temp_color
{_, true, _} -> pass_1
{_, _, true} -> pass_2 + (pass_1 - pass_2) * (0.666 - temp_color) * 6
_ -> pass_2
end
end
end
defimpl String.Chars, for: CSSEx.RGBA do
def to_string(%CSSEx.RGBA{r: r, g: g, b: b, a: a}), do: "rgba(#{r},#{g},#{b},#{a})"
end
|
lib/structs/rgba.ex
| 0.84241 | 0.502502 |
rgba.ex
|
starcoder
|
defmodule Advent.Y2021.D11 do
@moduledoc """
https://adventofcode.com/2021/day/11
"""
@typep point :: {non_neg_integer(), non_neg_integer()}
@typep grid :: %{point => non_neg_integer()}
@doc """
Given the starting energy levels of the dumbo octopuses in your cavern,
simulate 100 steps. How many total flashes are there after 100 steps?
"""
@spec part_one(Enumerable.t(), non_neg_integer()) :: non_neg_integer()
def part_one(input, steps) do
input
|> parse_input()
|> Stream.unfold(&step/1)
|> Stream.take(steps)
|> Enum.sum()
end
@doc """
What is the first step during which all octopuses flash?
"""
@spec part_two(Enumerable.t()) :: non_neg_integer()
def part_two(input) do
grid = parse_input(input)
grid_size = map_size(grid)
grid
|> Stream.unfold(&step/1)
|> Stream.with_index(1)
|> Enum.find(fn {flashes, _step} -> flashes == grid_size end)
|> elem(1)
end
@spec parse_input(Enumerable.t()) :: grid()
defp parse_input(input) do
input
|> Stream.with_index()
|> Stream.flat_map(fn {line, row} ->
line
|> String.graphemes()
|> Enum.map(&String.to_integer/1)
|> Enum.with_index()
|> Enum.map(fn {energy, col} ->
{{col, row}, energy}
end)
end)
|> Map.new()
end
@spec step(grid()) :: {non_neg_integer(), grid()}
defp step(grid) do
grid = Map.map(grid, fn {_, e} -> rem(e + 1, 10) end)
{flash_points, num_flashes} =
Enum.reduce(grid, {[], 0}, fn
{point, 0}, {acc, n} -> {[point | acc], n + 1}
_, {acc, n} -> {acc, n}
end)
do_step(grid, flash_points, num_flashes)
end
@spec do_step(grid(), [point()], non_neg_integer()) :: {non_neg_integer(), grid()}
defp do_step(grid, [], num_flashes), do: {num_flashes, grid}
defp do_step(grid, flash_points, total_flashes) do
{grid, flash_points, num_flashes} =
flash_points
|> Enum.flat_map(&neighbors(grid, &1))
|> Enum.reduce({grid, [], 0}, fn point, {grid, acc, n} ->
{old, grid} =
Map.get_and_update(grid, point, fn
0 -> {0, 0}
e -> {e, rem(e + 1, 10)}
end)
if old == 9 do
{grid, [point | acc], n + 1}
else
{grid, acc, n}
end
end)
do_step(grid, flash_points, total_flashes + num_flashes)
end
@spec neighbors(grid(), point()) :: [point()]
defp neighbors(grid, {col, row}) do
# > Multiple generators can also be used to calculate the cartesian product
# > of two lists...
# -- https://elixir-lang.org/getting-started/comprehensions.html#generators-and-filters
for(x <- -1..1, y <- -1..1, {x, y} != {0, 0}, do: {col + x, row + y})
|> Enum.filter(&Map.has_key?(grid, &1))
end
end
|
lib/advent/y2021/d11.ex
| 0.82994 | 0.660662 |
d11.ex
|
starcoder
|
defmodule GingerbreadShop.Service.Store.Model do
use Ecto.Schema
import Ecto
import Ecto.Changeset
import Protecto
@moduledoc """
A model representing a store.
##Fields
###:id
Is the unique reference to the store entry. Is an `integer`.
###:entity
Is the entity the store belongs to. Is an `UUID`.
###:public
Whether the store is publicly listed or private. Is a `boolean`.
###:status
Is the current operating status of the store. Is a `GingerbreadShop.Service.Store.StatusEnum`.
###:name
Is the name of the store. Is a `string`.
###:phone
Is the phone number of the store. Is a `string`.
###:address
Is the address of the store. Is a `map`.
###:place
Is the place/building complex the store is located at. Is a `string`.
###:geo
Is the longitude/latitude of where the store is located. Is a `geometry`. null: false
###:services
Are the services the store offers. Is a `map`.
###:assets
Are the image assets that have been associated with the store. Is a `map`.
"""
schema "stores" do
field :entity, Ecto.UUID
field :public, :boolean
field :status, GingerbreadShop.Service.Store.StatusEnum
field :name, :string
field :phone, :string
field :address, :map
field :place, :string
field :geo, Geo.Point
field :services, :map
field :assets, :map
timestamps()
end
@doc """
Builds a changeset for insertion based on the `struct` and `params`.
Enforces:
* `entity` field is required
* `public` field is required
* `status` field is required
* `name` field is required
* `phone` field is required
* `address` field is required
* `geo` field is required
* checks uniqueness of the entity
"""
def insert_changeset(struct, params \\ %{}) do
struct
|> cast(params, [:entity, :public, :status, :name, :phone, :address, :place, :geo, :services, :assets])
|> validate_required([:entity, :public, :status, :name, :phone, :address, :geo])
|> validate_phone_number(:phone)
|> unique_constraint(:entity)
end
@doc """
Builds a changeset for update based on the `struct` and `params`.
Enforces:
* `entity` field is not empty
* `public` field is not empty
* `status` field is not empty
* `name` field is not empty
* `phone` field is not empty
* `address` field is not empty
* `geo` field is not empty
* checks uniqueness of the entity
"""
def update_changeset(struct, params \\ %{}) do
struct
|> cast(params, [:entity, :public, :status, :name, :phone, :address, :place, :geo, :services, :assets])
|> validate_emptiness(:entity)
|> validate_emptiness(:public)
|> validate_emptiness(:status)
|> validate_emptiness(:name)
|> validate_emptiness(:phone)
|> validate_emptiness(:address)
|> validate_emptiness(:geo)
|> validate_phone_number(:phone)
|> unique_constraint(:entity)
end
end
|
apps/gingerbread_shop_service/lib/gingerbread_shop.service/store/model.ex
| 0.831793 | 0.604807 |
model.ex
|
starcoder
|
defmodule Google.Protobuf.Compiler.Version do
@moduledoc false
alias Pbuf.Decoder
import Bitwise, only: [bsr: 2, band: 2]
@derive Jason.Encoder
defstruct [
major: nil,
minor: nil,
patch: nil,
suffix: nil
]
@type t :: %__MODULE__{
major: integer,
minor: integer,
patch: integer,
suffix: String.t
}
@spec new(Enum.t) :: t
def new(data) do
struct(__MODULE__, data)
end
@spec encode_to_iodata!(t | map) :: iodata
def encode_to_iodata!(data) do
alias Elixir.Pbuf.Encoder
[
Encoder.field(:int32, data.major, <<8>>),
Encoder.field(:int32, data.minor, <<16>>),
Encoder.field(:int32, data.patch, <<24>>),
Encoder.field(:string, data.suffix, <<34>>),
]
end
@spec encode!(t | map) :: binary
def encode!(data) do
:erlang.iolist_to_binary(encode_to_iodata!(data))
end
@spec decode!(binary) :: t
def decode!(data) do
Decoder.decode!(__MODULE__, data)
end
@spec decode(binary) :: {:ok, t} | :error
def decode(data) do
Decoder.decode(__MODULE__, data)
end
def decode(acc, <<8, data::binary>>) do
Decoder.field(:int32, :major, acc, data)
end
def decode(acc, <<16, data::binary>>) do
Decoder.field(:int32, :minor, acc, data)
end
def decode(acc, <<24, data::binary>>) do
Decoder.field(:int32, :patch, acc, data)
end
def decode(acc, <<34, data::binary>>) do
Decoder.field(:string, :suffix, acc, data)
end
# failed to decode, either this is an unknown tag (which we can skip), or
# it is a wrong type (which is an error)
def decode(acc, data) do
{prefix, data} = Decoder.varint(data)
tag = bsr(prefix, 3)
type = band(prefix, 7)
case tag in [1,2,3,4] do
false -> {acc, Decoder.skip(type, data)}
true ->
err = %Decoder.Error{
tag: tag,
module: __MODULE__,
message: "#{__MODULE__} tag #{tag} has an incorrect type of #{type}"
}
{:error, err}
end
end
def __finalize_decode__(args) do
struct = Elixir.Enum.reduce(args, %__MODULE__{}, fn
{k, v}, acc -> Map.put(acc, k, v)
end)
struct
end
end
defmodule Google.Protobuf.Compiler.CodeGeneratorRequest do
@moduledoc false
alias Pbuf.Decoder
import Bitwise, only: [bsr: 2, band: 2]
@derive Jason.Encoder
defstruct [
file_to_generate: [],
parameter: nil,
compiler_version: nil,
proto_file: []
]
@type t :: %__MODULE__{
file_to_generate: [String.t],
parameter: String.t,
compiler_version: Google.Protobuf.Compiler.Version.t,
proto_file: [Google.Protobuf.FileDescriptorProto.t]
}
@spec new(Enum.t) :: t
def new(data) do
struct(__MODULE__, data)
end
@spec encode_to_iodata!(t | map) :: iodata
def encode_to_iodata!(data) do
alias Elixir.Pbuf.Encoder
[
Encoder.repeated_unpacked_field(:string, data.file_to_generate, <<10>>),
Encoder.field(:string, data.parameter, <<18>>),
Encoder.field(:struct, data.compiler_version, <<26>>),
Encoder.repeated_unpacked_field(:struct, data.proto_file, <<122>>),
]
end
@spec encode!(t | map) :: binary
def encode!(data) do
:erlang.iolist_to_binary(encode_to_iodata!(data))
end
@spec decode!(binary) :: t
def decode!(data) do
Decoder.decode!(__MODULE__, data)
end
@spec decode(binary) :: {:ok, t} | :error
def decode(data) do
Decoder.decode(__MODULE__, data)
end
def decode(acc, <<10, data::binary>>) do
Decoder.field(:string, :file_to_generate, acc, data)
end
def decode(acc, <<18, data::binary>>) do
Decoder.field(:string, :parameter, acc, data)
end
def decode(acc, <<26, data::binary>>) do
Decoder.struct_field(Google.Protobuf.Compiler.Version, :compiler_version, acc, data)
end
def decode(acc, <<122, data::binary>>) do
Decoder.struct_field(Google.Protobuf.FileDescriptorProto, :proto_file, acc, data)
end
# failed to decode, either this is an unknown tag (which we can skip), or
# it is a wrong type (which is an error)
def decode(acc, data) do
{prefix, data} = Decoder.varint(data)
tag = bsr(prefix, 3)
type = band(prefix, 7)
case tag in [1,2,3,15] do
false -> {acc, Decoder.skip(type, data)}
true ->
err = %Decoder.Error{
tag: tag,
module: __MODULE__,
message: "#{__MODULE__} tag #{tag} has an incorrect type of #{type}"
}
{:error, err}
end
end
def __finalize_decode__(args) do
struct = Elixir.Enum.reduce(args, %__MODULE__{}, fn
{:proto_file, v}, acc -> Map.update(acc, :proto_file, [v], fn e -> [v | e] end)
{:file_to_generate, v}, acc -> Map.update(acc, :file_to_generate, [v], fn e -> [v | e] end)
{k, v}, acc -> Map.put(acc, k, v)
end)
struct = Map.put(struct, :proto_file, Elixir.Enum.reverse(struct.proto_file))
struct = Map.put(struct, :file_to_generate, Elixir.Enum.reverse(struct.file_to_generate))
struct
end
end
defmodule Google.Protobuf.Compiler.CodeGeneratorResponse do
@moduledoc false
alias Pbuf.Decoder
import Bitwise, only: [bsr: 2, band: 2]
@derive Jason.Encoder
defstruct [
error: nil,
file: []
]
@type t :: %__MODULE__{
error: String.t,
file: [Google.Protobuf.Compiler.CodeGeneratorResponse.File.t]
}
@spec new(Enum.t) :: t
def new(data) do
struct(__MODULE__, data)
end
@spec encode_to_iodata!(t | map) :: iodata
def encode_to_iodata!(data) do
alias Elixir.Pbuf.Encoder
[
Encoder.field(:string, data.error, <<10>>),
Encoder.repeated_unpacked_field(:struct, data.file, <<122>>),
]
end
@spec encode!(t | map) :: binary
def encode!(data) do
:erlang.iolist_to_binary(encode_to_iodata!(data))
end
@spec decode!(binary) :: t
def decode!(data) do
Decoder.decode!(__MODULE__, data)
end
@spec decode(binary) :: {:ok, t} | :error
def decode(data) do
Decoder.decode(__MODULE__, data)
end
def decode(acc, <<10, data::binary>>) do
Decoder.field(:string, :error, acc, data)
end
def decode(acc, <<122, data::binary>>) do
Decoder.struct_field(Google.Protobuf.Compiler.CodeGeneratorResponse.File, :file, acc, data)
end
# failed to decode, either this is an unknown tag (which we can skip), or
# it is a wrong type (which is an error)
def decode(acc, data) do
{prefix, data} = Decoder.varint(data)
tag = bsr(prefix, 3)
type = band(prefix, 7)
case tag in [1,15] do
false -> {acc, Decoder.skip(type, data)}
true ->
err = %Decoder.Error{
tag: tag,
module: __MODULE__,
message: "#{__MODULE__} tag #{tag} has an incorrect type of #{type}"
}
{:error, err}
end
end
def __finalize_decode__(args) do
struct = Elixir.Enum.reduce(args, %__MODULE__{}, fn
{:file, v}, acc -> Map.update(acc, :file, [v], fn e -> [v | e] end)
{k, v}, acc -> Map.put(acc, k, v)
end)
struct = Map.put(struct, :file, Elixir.Enum.reverse(struct.file))
struct
end
end
defmodule Google.Protobuf.Compiler.CodeGeneratorResponse.File do
@moduledoc false
alias Pbuf.Decoder
import Bitwise, only: [bsr: 2, band: 2]
@derive Jason.Encoder
defstruct [
name: nil,
insertion_point: nil,
content: nil
]
@type t :: %__MODULE__{
name: String.t,
insertion_point: String.t,
content: String.t
}
@spec new(Enum.t) :: t
def new(data) do
struct(__MODULE__, data)
end
@spec encode_to_iodata!(t | map) :: iodata
def encode_to_iodata!(data) do
alias Elixir.Pbuf.Encoder
[
Encoder.field(:string, data.name, <<10>>),
Encoder.field(:string, data.insertion_point, <<18>>),
Encoder.field(:string, data.content, <<122>>),
]
end
@spec encode!(t | map) :: binary
def encode!(data) do
:erlang.iolist_to_binary(encode_to_iodata!(data))
end
@spec decode!(binary) :: t
def decode!(data) do
Decoder.decode!(__MODULE__, data)
end
@spec decode(binary) :: {:ok, t} | :error
def decode(data) do
Decoder.decode(__MODULE__, data)
end
def decode(acc, <<10, data::binary>>) do
Decoder.field(:string, :name, acc, data)
end
def decode(acc, <<18, data::binary>>) do
Decoder.field(:string, :insertion_point, acc, data)
end
def decode(acc, <<122, data::binary>>) do
Decoder.field(:string, :content, acc, data)
end
# failed to decode, either this is an unknown tag (which we can skip), or
# it is a wrong type (which is an error)
def decode(acc, data) do
{prefix, data} = Decoder.varint(data)
tag = bsr(prefix, 3)
type = band(prefix, 7)
case tag in [1,2,15] do
false -> {acc, Decoder.skip(type, data)}
true ->
err = %Decoder.Error{
tag: tag,
module: __MODULE__,
message: "#{__MODULE__} tag #{tag} has an incorrect type of #{type}"
}
{:error, err}
end
end
def __finalize_decode__(args) do
struct = Elixir.Enum.reduce(args, %__MODULE__{}, fn
{k, v}, acc -> Map.put(acc, k, v)
end)
struct
end
end
|
lib/protoc/google/protobuf/compiler/plugin.pb.ex
| 0.794704 | 0.522872 |
plugin.pb.ex
|
starcoder
|
defmodule Sippet.Proxy do
@moduledoc """
Defines very basic operations commonly used in SIP Proxies.
"""
alias Sippet.Message, as: Message
alias Sippet.Message.RequestLine, as: RequestLine
alias Sippet.Message.StatusLine, as: StatusLine
alias Sippet.URI, as: URI
alias Sippet.Transactions, as: Transactions
alias Sippet.Transports, as: Transports
@type client_key :: Transactions.Client.Key.t
@type request :: Message.request
@type on_request_sent ::
{:ok, client_key, request} |
{:error, reason :: term} |
no_return
@type on_request_sent_stateless ::
{:ok, request} |
{:error, reason :: term} |
no_return
@type on_response_sent ::
:ok |
{:error, reason :: term} |
no_return
@doc """
Adds a Record-Route header to the request.
When a proxy wishes to remain on the path of future requests in a dialog
created by this request (assuming the request creates a dialog), it inserts a
Record-Route header field value in the request, before forwarding.
The indicated `hop` parameter should indicate the destination where requests
and responses in a dialog should pass. The `hop` SIP-URI will get a `"lr"`
parameter, if it does not have one, and will be placed as the first header
value.
"""
@spec add_record_route(Message.request, URI.t) :: Message.request
def add_record_route(%Message{start_line: %RequestLine{}} = request,
%URI{} = hop) do
parameters =
if hop.parameters == nil do
";lr"
else
hop.parameters
|> URI.decode_parameters()
|> Map.put("lr", nil)
|> URI.encode_parameters()
end
record_route = {"", %{hop | parameters: parameters}, %{}}
request |> Message.update_header(:record_route, [record_route],
fn list -> [record_route | list] end)
end
@doc """
Adds a Via header to the request.
A proxy must insert a Via header field value before the existing request Via
header field values. A `"branch"` parameter will be randomly computed as
being a 72-bit random string starting with the magic cookie `"z9hG4bK"`.
"""
@spec add_via(Message.request, Message.protocol, host :: String.t,
dport :: integer) :: Message.request
def add_via(%Message{start_line: %RequestLine{}} = request,
protocol, host, port) do
add_via(request, protocol, host, port, Message.create_branch())
end
@doc """
Adds a Via header to the request with a supplied `branch`.
A proxy must insert a Via header field value before the existing request Via
header field values. If the `branch` parameter does not start with the magic
cookie `"z9hG4bK"`, one will be added.
"""
@spec add_via(Message.request, Message.protocol, host :: String.t,
dport :: integer, branch :: String.t) :: Message.request
def add_via(%Message{start_line: %RequestLine{}} = request,
protocol, host, port, branch) do
branch =
if branch |> String.starts_with?(Sippet.Message.magic_cookie) do
branch
else
Sippet.Message.magic_cookie <> branch
end
params = %{"branch" => branch}
new_via = {{2, 0}, protocol, {host, port}, params}
request |> Message.update_header(:via, [new_via],
fn list -> [new_via | list] end)
end
@doc """
Returns a binary representing a textual branch identifier obtained from the
topmost Via header of the request.
This derived branch has the property to be the same case the topmost Via
header of the `request` is also the same, as in the case of retransmissions.
This operation is usually performed for stateless proxying, like in the case
of ACK requests, and contains the magic cookie. In order to correctly derive
the branch, the input `request` must not have been modified after reception.
"""
@spec derive_branch(request) :: binary
def derive_branch(%Message{start_line: %RequestLine{}} = request) do
[{_, _, _, %{"branch" => branch}} | _] = request.headers.via
input =
if branch |> String.starts_with?(Message.magic_cookie) do
branch
else
request_uri = URI.to_string(request.start_line.request_uri)
[{_, protocol, {address, port}, params} | _] = request.headers.via
{_, _, %{"tag" => from_tag}} = request.headers.from
call_id = request.headers.call_id
{sequence, _method} = request.headers.cseq
to_tag =
case request.headers.to do
{_, _, %{"tag" => to_tag}} ->
to_tag
_other ->
""
end
via_params =
Map.to_list(params)
|> Enum.reduce([], fn {k, v}, acc -> [k, v | acc] end)
[request_uri, to_string(protocol), address, to_string(port),
call_id, from_tag, to_tag, to_string(sequence), via_params]
end
hash =
:crypto.hmac(:ripemd160, "sippet", input)
|> Base.url_encode64(padding: false)
Message.magic_cookie <> hash
end
@doc """
Forwards the request statefully.
The request is sent using a client transaction. If it cannot be sent using
one, it will raise an exception.
This function will honor the start line `request_uri`.
"""
@spec forward_request(Message.request) :: on_request_sent
def forward_request(%Message{start_line: %RequestLine{}} = request) do
request =
request
|> do_handle_max_forwards()
|> do_maybe_handle_route()
case request |> Transactions.send_request() do
{:ok, client_key} -> {:ok, client_key, request}
other -> other
end
end
defp do_handle_max_forwards(message) do
if message |> Message.has_header?(:max_forwards) do
max_fws = message.headers.max_forwards
if max_fws <= 0 do
raise ArgumentError, "invalid :max_forwards => #{inspect max_fws}"
else
message |> Message.put_header(:max_forwards, max_fws - 1)
end
else
message |> Message.put_header(:max_forwards, 70)
end
end
defp do_maybe_handle_route(%Message{start_line: %RequestLine{}} = request) do
{is_strict, target_uri} =
if request |> Message.has_header?(:route) do
{_, target_uri, _} = hd(request.headers.route)
if target_uri.parameters == nil do
{false, nil}
else
case URI.decode_parameters(target_uri.parameters) do
%{"lr" => _} -> {false, nil}
_no_lr -> {true, target_uri}
end
end
else
{false, nil}
end
if is_strict do
# strict-routing requirements
request_uri = request.start_line.request_uri
request =
request
|> Message.put_header_back(:route, {"", request_uri, %{}})
|> Message.delete_header_front(:route)
%{request | start_line:
%{request.start_line | request_uri: target_uri}}
else
request # no change
end
end
@doc """
Forwards the request to a given `request_uri`.
If the method is `:ack`, the request will be sent directly to the network transport.
Otherwise, a new client transaction will be created.
This function will override the start line `request_uri` with the supplied one.
"""
@spec forward_request(Message.request, URI.t) :: on_request_sent
def forward_request(%Message{start_line: %RequestLine{}} = request,
%URI{} = request_uri) do
%{request | start_line: %{request.start_line | request_uri: request_uri}}
|> forward_request()
end
@doc """
Forwards the request statelessly.
The request will be sent directly to the network transport.
"""
@spec stateless_forward_request(request) :: on_request_sent_stateless
def stateless_forward_request(
%Message{start_line: %RequestLine{}} = request) do
request =
request
|> do_handle_max_forwards()
|> do_maybe_handle_route()
request |> Transports.send_message(nil)
{:ok, request}
end
@doc """
Forwards a response.
You should check and remove the topmost Via before calling this function.
The response will find its way back to an existing server transaction, if one
exists, or will be sent directly to the network transport otherwise.
"""
@spec forward_response(Message.response) :: on_response_sent
def forward_response(%Message{start_line: %StatusLine{}} = response) do
response
|> fallback_to_transport(&Transactions.send_response/1)
end
defp fallback_to_transport(message, fun) do
case fun.(message) do
{:error, :no_transaction} ->
message |> Transports.send_message()
other ->
other
end
end
@doc """
Forwards a response using an existing server transaction key.
See `forward_response/1`.
"""
@spec forward_response(Message.response, Transactions.Server.Key.t)
:: on_response_sent
def forward_response(%Message{start_line: %StatusLine{}} = response,
%Transactions.Server.Key{} = server_key) do
response
|> fallback_to_transport(&Transactions.send_response(&1, server_key))
end
end
|
lib/sippet/proxy.ex
| 0.869853 | 0.400749 |
proxy.ex
|
starcoder
|
defmodule Dion.Lexers.RST.Inline do
@moduledoc """
Provides function used to perform lexical analysis, searching for
inline reStructuredText (RST) elements.
"""
@moduledoc since: "0.1.0"
@doc """
Performs inline lexical analysis on the provided text.
The `lineno` argument is set on the return elements for reference and
error reporting purposes.
"""
def lex(text, lineno) do
text
|> String.split(~r/ +/)
|> Enum.map(
fn word -> format(word, lineno) end
)
|> Stream.map(&Task.async(Dion.Lexers.RST.Inline, :analyze_init, [&1]))
|> Enum.map(&Task.await(&1))
|> List.flatten
|> Stream.map(&Task.async(Dion.Lexers.RST.Inline, :analyze_term, [&1]))
|> Enum.map(&Task.await(&1))
|> List.flatten
end
@doc """
Formats the given string, setting line number, type, text, observe and reverse
enumerated text, text, and raw text.
"""
@doc since: "0.1.0"
def format(text, lineno, type) do
graph = String.graphemes(text)
data = %{
lineno: lineno,
rawtext: text,
text: text,
chars: graph,
rchars: Enum.reverse(graph),
type: :string
}
if type == nil do
data
else
Map.put(data, :type, type)
end
end
def format(text, lineno) do
format(text, lineno, nil)
end
@doc """
Removes initial characters and reanalyzes the start of the string.
"""
@doc since: "0.1.0"
def strip_init(word, chars) do
format(
String.slice(word[:text], chars..-1),
word[:lineno]
)
|> analyze_init
end
@doc """
Removes terminal characters and reanalyzes the end of the string.
"""
@doc since: "0.1.0"
def strip_term(word, chars) do
format(
String.slice(word[:text], 0..chars),
word[:lineno]
)
|> analyze_term
end
@doc """
Performs lexical analysis on the start of the string.
"""
@doc since: "0.1.0"
def analyze_init(word) do
case word[:chars] do
# Bold
["*", "*" | _] -> [:open_bold, strip_init(word, 2)]
["*" | _] -> [:open_italic, strip_init(word, 1)]
["`", "`" | _] -> [:open_code, strip_init(word, 2)]
["`" | _] -> [:open_literal, strip_init(word, 1)]
["\"" | _] -> [:open_quote, strip_init(word, 2)]
[":" | _] -> [:open_colon, strip_init(word, 1)]
["_" | _] -> [:open_score, strip_init(word, 1)]
_ -> [word]
end
end
@doc """
Evaluates the given word, returns atoms without conideration and passes
maps on for lexical analysis of the end of the string.
"""
@doc since: "0.1.0"
def analyze_term(word) do
if is_atom(word) do
word
else
analyze_term_content(word)
end
end
@doc """
Performs lexical analysis on the end of the string.
"""
@doc since: "0.1.0"
def analyze_term_content(word) do
term = Enum.at(word[:rchars], 0)
cond do
# Punctation
term in [".", ",", ";", "'", "?", "-", "]", ")", "}"] ->
[strip_term(word, -2), format(term, word[:lineno], :punct)]
true ->
case word[:rchars] do
["*", "*" | _] -> [strip_term(word, -3), :close_bold]
["*" | _] -> [strip_term(word, -2), :close_italic]
["`", "`" | _] -> [strip_term(word, -3), :close_code]
["`" | _] -> [strip_term(word, -2), :close_literal]
["\"" | _] -> [strip_term(word, -2), :close_quote]
[":" | _] -> [strip_term(word, -2), :close_colon]
["_" | _] -> [strip_term(word, -2), :close_score]
_ -> [word]
end
end
end
end
|
lib/dion/lexers/rst/inline.ex
| 0.725649 | 0.498779 |
inline.ex
|
starcoder
|
defmodule Samples do
def extract(contents, type) do
contents
|> extract_table_parts
|> (fn {vars, _type, keyword_lists} -> {vars, type, keyword_lists} end).()
|> process_table_parts
end
def extract(contents) do
contents
|> extract_table_parts
|> process_table_parts
end
defp extract_table_parts(contents) do
{vars, type, fields, fields_values} =
contents
|> normalize_contents
|> contents_to_table
|> slice_table
keyword_lists = zip_fields_and_values(fields, fields_values)
{vars, type, keyword_lists}
end
defp process_table_parts({[], type, keyword_lists}) do
to_typed_list(keyword_lists, type)
end
defp process_table_parts({vars, type, keyword_lists}) do
to_assignments(vars, type, keyword_lists)
end
defp slice_table(table) do
[header | rows] = extract_header_rows(table)
{type, fields} = extract_type_and_fields(header)
{vars, fields_values} = extract_vars_and_fields_values(type, rows)
{vars, type, fields, fields_values}
end
defp to_assignments(vars, type, keyword_lists) do
vars
|> Enum.zip(keyword_lists)
|> Enum.map(fn {var_name, value} ->
var = Macro.var(var_name, nil)
quote do
unquote(var) = unquote(replace_value(type, value))
end
end)
end
defp to_typed_list(contents, nil) do
to_typed_list(contents, {:%{}, [], []})
end
defp to_typed_list(contents, type) do
Enum.map(contents, fn item ->
replace_value(type, item)
end)
end
defp extract_header_rows([]), do: [[nil]]
defp extract_header_rows(table), do: table
def extract_type_and_fields([type = {atom, _, []} | fields]) when atom == :%{} do
{type, fields}
end
def extract_type_and_fields([{:__aliases__, _, [_]} = type | fields]) do
{type, fields}
end
def extract_type_and_fields(fields = [{field, [_], _} | _]) when is_atom(field) do
{nil, Enum.map(fields, fn {field, [_], _} -> field end)}
end
def extract_type_and_fields(fields = [field | _]) when is_atom(field) do
{nil, fields}
end
def extract_type_and_fields([type | fields]) do
{type, fields}
end
def extract_vars_and_fields_values(nil, rows) do
{[], rows}
end
def extract_vars_and_fields_values(_type, rows) do
rows
|> Enum.map(fn [{var, [line: _line], _} | fields_values] -> {var, fields_values} end)
|> :lists.unzip()
end
defp zip_fields_and_values(fields, rows) do
Enum.map(rows, fn row ->
Enum.zip(fields, row)
end)
end
# As structs by module name
defp replace_value({:__aliases__, [counter: _, line: _], [module]}, value) do
{:%, [], [{:__aliases__, [], [module]}, {:%{}, [], value}]}
end
defp replace_value({:__aliases__, [line: _], [module]}, value) do
{:%, [], [{:__aliases__, [], [module]}, {:%{}, [], value}]}
end
# As structs
defp replace_value({:%, meta, [lhs, {:%{}, _, _value}]}, value) do
{:%, meta, [lhs, {:%{}, [], value}]}
end
# As maps
defp replace_value({:%{}, meta, []}, value) do
{:%{}, meta, value}
end
# As keyword list
defp replace_value([], value) do
value
end
defp contents_to_table(contents) do
case contents do
[do: nil] -> []
nil -> []
_ -> extract_rows(contents)
end
end
defp extract_rows(contents) do
contents |> Enum.map(&extract_row(&1))
end
defp extract_row([row]) do
row |> extract_row
end
defp extract_row(row) do
row |> extract_cells([]) |> Enum.reverse()
end
defp extract_cells({:|, _, [lhs, rhs]}, values) do
rhs |> extract_cells([lhs | values])
end
defp extract_cells(value, values) do
[value | values]
end
defp normalize_contents(contents) do
case contents do
[do: {:__block__, _, code}] -> code
[do: code] -> [code]
end
end
end
|
lib/samples.ex
| 0.581065 | 0.458349 |
samples.ex
|
starcoder
|
defmodule GitGud.OAuth2.Provider do
@moduledoc """
OAuth2.0 provider schema and helper functions.
"""
use Ecto.Schema
alias GitGud.DB
alias GitGud.Account
import Ecto.Changeset
schema "oauth2_providers" do
belongs_to :account, Account
field :provider, :string
field :provider_id, :integer
field :token, :string
timestamps()
end
@type t :: %__MODULE__{
id: pos_integer,
account_id: pos_integer,
account: Account.t,
provider: binary,
provider_id: pos_integer,
token: binary,
inserted_at: NaiveDateTime.t,
updated_at: NaiveDateTime.t
}
@doc """
Creates a new OAuth2.0 provider with the given `params`.
```elixir
{:ok, provider} = GitGud.OAuth2.Provider.create(auth_id: user.account.id, provider: "github", provider_id: 12345, token: "<PASSWORD>")
```
This function validates the given `params` using `changeset/2`.
"""
@spec create(map|keyword) :: {:ok, t} | {:error, Ecto.Changeset.t}
def create(params) do
DB.insert(changeset(%__MODULE__{}, Map.new(params)))
end
@doc """
Similar to `create/1`, but raises an `Ecto.InvalidChangesetError` if an error occurs.
"""
@spec create!(map|keyword) :: t
def create!(params) do
DB.insert!(changeset(%__MODULE__{}, Map.new(params)))
end
@doc """
Deletes the given OAuth2.0 `provider`.
"""
@spec delete(t) :: {:ok, t} | {:error, Ecto.Changeset.t}
def delete(%__MODULE__{} = provider) do
DB.delete(provider)
end
@doc """
Similar to `delete!/1`, but raises an `Ecto.InvalidChangesetError` if an error occurs.
"""
@spec delete!(t) :: t
def delete!(%__MODULE__{} = provider) do
DB.delete!(provider)
end
@doc """
Returns an authentication provider changeset for the given `params`.
"""
@spec changeset(t, map) :: Ecto.Changeset.t
def changeset(%__MODULE__{} = provider, params \\ %{}) do
provider
|> cast(params, [:account_id, :provider, :provider_id, :token])
|> validate_required([:provider, :provider_id, :token])
|> assoc_constraint(:account)
|> unique_constraint(:provider_id, name: :authentication_providers_provider_provider_id_index)
end
end
|
apps/gitgud/lib/gitgud/schemas/oauth2_provider.ex
| 0.839405 | 0.695015 |
oauth2_provider.ex
|
starcoder
|
defmodule TelemetryMetricsPrometheus.Core do
@moduledoc """
Prometheus Reporter for [`Telemetry.Metrics`](https://github.com/beam-telemetry/telemetry_metrics) definitions.
Provide a list of metric definitions to the `child_spec/1` function. It's recommended to
add this to your supervision tree.
def start(_type, _args) do
# List all child processes to be supervised
children = [
{TelemetryMetricsPrometheus.Core, [
metrics: [
counter("http.request.count"),
sum("http.request.payload_size", unit: :byte),
last_value("vm.memory.total", unit: :byte)
]
]}
]
opts = [strategy: :one_for_one, name: ExampleApp.Supervisor]
Supervisor.start_link(children, opts)
end
Note that aggregations for distributions (histogram) only occur at scrape time.
These aggregations only have to process events that have occurred since the last
scrape, so it's recommended at this time to keep an eye on scrape durations if
you're reporting a large number of distributions or you have a high tag cardinality.
## Telemetry.Metrics to Prometheus Equivalents
Metric types:
* Counter - Counter
* Distribution - Histogram
* LastValue - Gauge
* Sum - Counter
* Summary - Summary (Not supported)
### Units
Prometheus recommends the usage of base units for compatibility - [Base Units](https://prometheus.io/docs/practices/naming/#base-units).
This is simple to do with `:telemetry` and `Telemetry.Metrics` as all memory
related measurements in the BEAM are reported in bytes and Metrics provides
automatic time unit conversions.
Note that measurement unit should used as part of the reported name in the case of
histograms and gauges to Prometheus. As such, it is important to explicitly define
the unit of measure for these types when the unit is time or memory related.
It is suggested to not mix units, e.g. seconds with milliseconds.
It is required to define your buckets according to the end unit translation
since this measurements are converted at the time of handling the event, prior
to bucketing.
#### Memory
Report memory as `:byte`.
#### Time
Report durations as `:second`. The BEAM and `:telemetry` events use `:native` time
units. Converting to seconds is as simple as adding the conversion tuple for
the unit - `{:native, :second}`
### Naming
`Telemetry.Metrics` definition names do not translate easily to Prometheus naming
conventions. By default, the name provided when creating your definition uses parts
of the provided name to determine what event to listen to and which event measurement
to use.
For example, `"http.request.duration"` results in listening for `[:http, :request]`
events and use `:duration` from the event measurements. Prometheus would recommend
a name of `http_request_duration_seconds` as a good name.
It is therefore recommended to use the name in your definition to reflect the name
you wish to see reported, e.g. `http.request.duration.seconds` or `[:http, :request, :duration, :seconds]` and use the `:event_name` override and `:measurement` options in your definition.
Example:
Metrics.distribution(
"http.request.duration.seconds",
event_name: [:http, :request, :complete],
measurement: :duration,
unit: {:native, :second},
reporter_options: [
buckets: [0.01, 0.025, 0.05, 0.1, 0.2, 0.5, 1]
]
)
The exporter sanitizes names to Prometheus' requirements ([Metric Naming](https://prometheus.io/docs/instrumenting/writing_exporters/#naming)) and joins the event name parts with an underscore.
### Labels
Labels in Prometheus are referred to as `:tags` in `Telemetry.Metrics` - see the docs
for more information on tag usage.
**Important: Each tag + value results in a separate time series. For distributions, this
is further complicated as a time series is created for each bucket plus one for measurements
exceeding the limit of the last bucket - `+Inf`.**
It is recommended, but not required, to abide by Prometheus' best practices regarding labels -
[Label Best Practices](https://prometheus.io/docs/practices/naming/#labels)
### Missing or Invalid Measurements and Tags
If a measurement value is missing or non-numeric, the error is logged at the `debug` level
and the event is not recorded. Events with missing tags are also logged and skipped.
"""
alias Telemetry.Metrics
alias TelemetryMetricsPrometheus.Core.{Aggregator, Exporter, Registry}
require Logger
@type metrics :: [Metrics.t()]
@type prometheus_option ::
{:metrics, metrics()}
| {:name, atom()}
@type prometheus_options :: [prometheus_option()]
@doc """
Reporter's child spec.
This function allows you to start the reporter under a supervisor like this:
children = [
{TelemetryMetricsPrometheus.Core, options}
]
See `start_child/1` for options.
"""
@spec child_spec(prometheus_options()) :: Supervisor.child_spec()
def child_spec(options) do
opts = ensure_options(options)
id =
case Keyword.get(opts, :name, :prometheus_metrics) do
name when is_atom(name) -> name
{:global, name} -> name
{:via, _, name} -> name
end
spec = %{
id: id,
start: {Registry, :start_link, [opts]}
}
Supervisor.child_spec(spec, [])
end
@doc """
Start the `TelemetryMetricsPrometheus.Core.Supervisor`
Available options:
* `:name` - name of the reporter instance. Defaults to `:prometheus_metrics`
* `:metrics` - a list of metrics to track.
"""
@spec start_link(prometheus_options()) :: GenServer.on_start()
def start_link(options) do
opts = ensure_options(options)
Registry.start_link(opts)
end
@doc """
Returns a metrics scrape in Prometheus exposition format for the given reporter
name - defaults to `:prometheus_metrics`.
"""
@spec scrape(name :: atom()) :: String.t()
def scrape(name \\ :prometheus_metrics) do
config = Registry.config(name)
metrics = Registry.metrics(name)
:ok = Aggregator.aggregate(metrics, config.aggregates_table_id, config.dist_table_id)
Aggregator.get_time_series(config.aggregates_table_id)
|> Exporter.export(metrics)
end
@spec ensure_options(prometheus_options()) :: prometheus_options()
defp ensure_options(options) do
Keyword.merge(default_options(), options)
end
@spec default_options() :: prometheus_options()
defp default_options() do
[
name: :prometheus_metrics
]
end
end
|
lib/core.ex
| 0.935236 | 0.632716 |
core.ex
|
starcoder
|
defmodule ToyRobot.Api do
@moduledoc """
The Api module contains the common higher level functions
that are called from the Command Line `ToyRobot.Cli`
and File Driven `ToyRobot.FromFile` interfaces.
This includes functions to:
- start and stop the `ToyRobot.Server`
- run commands
- get server state
- load a command file
- and check if command text is vlaid
Aliased Modules
ToyRobot.Server
ToyRobot.Parser
ToyRobot.Logic
"""
alias ToyRobot.Server
alias ToyRobot.Parser
alias ToyRobot.Logic
@doc """
Starts a supervised gen_server to manage state
for the current position of the toy robot.
See: `ToyRobot.Server`
## Examples
iex> start_server()
{:ok, server_pid}
"""
def start_server() do
Server.start_link()
end
@doc """
Parses a command via `ToyRobot.Parser.parse_command/1`
Which converts the command to a map in the form of `%{cmd: cmd, x: x, y: y, face: face}`
then pipes to process_cmd/1.
Valid but un-runnable command, such as a "MOVE" that would cause the ToyRobot to fall off the table will be ignored.
## Aguments
cmd: String
Server_pid: PID (Process ID)
## Examples
iex> ToyRobot.Api.run_cmd("MOVE", server_pid)
:ok
iex> ToyRobot.Api.run_cmd(10, server_pid)
nil
"""
def run_cmd(cmd, server_pid) do
if is_binary(cmd) do
Parser.parse_command(cmd)
|> process_cmd(server_pid)
end
end
@doc """
Processes commands to update servers state.
Takes a `ToyRobot.Logic` Struct and the `ToyRobot.Server` PID and delegates
valid commands to command calls in the ToyRobot.Server.
Invalid commands will print: "invalid commad command_name".
"""
def process_cmd(map, server_pid) do
# IO.puts("processing cmd: #{inspect(map)}")
if (map.cmd in Parser.cmds()) do
cond do
map.cmd == "MOVE" -> Server.move(server_pid)
map.cmd == "LEFT" -> Server.left(server_pid)
map.cmd == "RIGHT" -> Server.right(server_pid)
map.cmd == "PLACE" -> Server.place(server_pid, [map.x, map.y, map.face])
map.cmd == "REPORT" -> cur_state = get_server_state(server_pid)
Logic.report(cur_state)
true -> IO.puts("invalid commad: #{map.cmd}")
end
end
end
@doc """
Gets the current state of the ToyRobot.
Delegates to `ToyRobot.Server.current_state(server_pid)`.
Returns a ToyRobot.Logic struct in the form of: `%ToyRobot.Logic{face: :n, x: 0, y: 0}`
"""
def get_server_state(server_pid) do
Server.current_state(server_pid)
end
@doc """
Stops the server by delegating to `ToyRobot.Server.current_state(server_pid)`.
"""
def stop_server(server_pid) do
Process.exit(server_pid, :normal)
end
@doc """
Returns true if `command text (cmd_txt)` is valid, returns false otherwise.
"""
def valid_cmd?(cmd_txt) do
if cmd_txt != "" do
[cmd, _args] =
Parser.split_cmd_txt(cmd_txt)
|> Parser.validate_cmd()
!is_nil(cmd)
else
false
end
end
end
|
lib/toy_robot/api.ex
| 0.726329 | 0.568566 |
api.ex
|
starcoder
|
defmodule Kalevala.Character.Controller do
@moduledoc ~S"""
A `Kalevala.Character.Controller` is the largest building block of handling
texting. When starting the foreman, an initial controller is given. This
controller is initialized and used from then on. The callbacks required will
be called at the appropriate time with a new `Conn`.
Controllers act as a simple state machine, only allowing transitioning to the
next one you set in the `Conn`. For instance, you can contain all login logic
in a `LoginController`, and handle game commands in its own controller, any
paging can be handled in a `PagerController` which can suppress any outgoing
text to prevent scrolling while reading, etc.
## Example Controller
```elixir
defmodule Kantele.Character.LoginController do
use Kalevala.Character.Controller
# ... code
@impl true
def init(conn) do
conn
|> put_session(:login_state, :username)
|> render(LoginView, "welcome")
|> prompt(LoginView, "name")
end
@impl true
def recv_event(conn, event) do
case event.topic do
"Login" ->
conn
|> process_username(event.data["username"])
|> process_password(event.data["password"])
_ ->
conn
end
end
@impl true
def recv(conn, ""), do: conn
def recv(conn, data) do
data = String.trim(data)
case get_session(conn, :login_state) do
:username ->
process_username(conn, data)
:password ->
process_password(conn, data)
:registration ->
process_registration(conn, data)
end
end
defp process_username(conn, username) do
case username do
"" ->
prompt(conn, LoginView, "name")
<<4>> ->
conn
|> prompt(QuitView, "goodbye")
|> halt()
"quit" ->
conn
|> prompt(QuitView, "goodbye")
|> halt()
username ->
case Accounts.exists?(username) do
true ->
conn
|> put_session(:login_state, :password)
|> put_session(:username, username)
|> send_option(:echo, true)
|> prompt(LoginView, "password")
false ->
conn
|> put_session(:login_state, :registration)
|> put_session(:username, username)
|> prompt(LoginView, "check-registration")
end
end
end
# ... code ...
end
```
## Managing State (assigns, session, and flash)
Controller state is managed in one of three different ways, `session`, `assigns`, and
`flash`. These states are made avaiable to the `Views` which can utilize them as
variables as needed.
### Session
The `session` maintains state for the lifetime of the player connection. Session state
can be set using `put_session/3` and variables can be retrieved using `get_session/2`.
### Flash
The `flash` maintains state for the duration of a player's interaction with a single
controller. Switching between controllers will cause the flash to be reset.
### Assings
Assigns are temporary storage that allow the setting of variables to be made available
to `Views`
## Prompts and Render
A prompt is text that is sent followed by a newline character. The above code
`prompt(LoginView, "check-registration")` will render the the
`"check-registration"` prompt of the `LoginView` followed by a newline.
Render on the other outputs the text but is not followed by a newline. That
means contiguous calls to `render` will append the output to the same line
as the previous.
## Switching Controllers
Switching controllers is done by calling the
`Kalevala.Character.Conn.put_controller/2` function. This will immediately switch
to the provided controller and call it's `init/1` function.
"""
alias Kalevala.Character.Conn
alias Kalevala.Character.Event
@doc """
Called when the controller is first switched to
"""
@callback init(Conn.t()) :: Conn.t()
@doc """
Called when text is received from the player
"""
@callback recv(Conn.t(), String.t()) :: Conn.t()
@doc """
Called when the connection receives an event (e.g. incoming GMCP)
"""
@callback recv_event(Conn.t(), any()) :: Conn.t()
@doc """
Called when a `Kalevala.Character.Event` is sent to the foreman process
"""
@callback event(Conn.t(), Event.t()) :: Conn.t()
@doc """
Called when a `Kalevala.Character.Event.Display` is sent to the foreman process
"""
@callback display(Conn.t(), Event.t()) :: Conn.t()
@doc """
Marks the module as a controller and imports controller functions
"""
defmacro __using__(_opts) do
quote do
@behaviour unquote(__MODULE__)
import Kalevala.Character.Conn
require Logger
alias Kalevala.Character.Event
@impl true
def recv_event(conn, event) do
Logger.debug("Received event - #{inspect(event)}")
conn
end
@impl true
def event(conn, event) do
Logger.debug("Received event - #{inspect(event)}")
conn
end
@impl true
def display(conn, event) do
conn
|> Map.put(:options, event.options)
|> Map.put(:output, event.output)
end
defoverridable display: 2, event: 2, recv_event: 2
end
end
end
|
lib/kalevala/character/controller.ex
| 0.889156 | 0.836955 |
controller.ex
|
starcoder
|
defmodule Pixie.Monitor do
use Timex
@moduledoc """
Allows you to monitor various events within Pixie.
Internally Pixie.Monitor is implemented using GenEvent, so you're free to
bypass using the Pixie.Monitor behaviour and use your own GenEvent if the
need arises.
Usage example:
```elixir
defmodule MyMonitor do
use Pixie.Monitor
def created_channel channel_name, at do
Logger.info "Channel \#\{channel_name} created at \#\{format at}"
end
def destroyed_channel channel_name, at do
Logger.info "Channel \#\{channel_name} destroyed at \#\{format at}"
end
defp format timestamp do
timestamp
|> Date.from(:timestamp)
|> DateFormat.format!("{UNIX}")
end
end
```
"""
defmacro __using__(_opts) do
quote do
use GenEvent
use Timex
def handle_event({fun, args}, state) when is_atom(fun) and is_list(args) do
apply __MODULE__, fun, args
{:ok, state}
end
def created_client(_client_id, _at), do: :ok
def destroyed_client(_client_id, _reason, _at), do: :ok
def created_channel(_channel_name, _at), do: :ok
def destroyed_channel(_channel_name, _at), do: :ok
def client_subscribed(_client_id, _channel_name, _at), do: :ok
def client_unsubscribed(_client_id, _channel_name, _at), do: :ok
def received_message(_client_id, _message_id, _at), do: :ok
def delivered_message(_client_id, _message_id, _at), do: :ok
defoverridable [
created_client: 2,
destroyed_client: 3,
created_channel: 2,
destroyed_channel: 2,
client_subscribed: 3,
client_unsubscribed: 3,
received_message: 3,
delivered_message: 3
]
end
end
@doc """
Called when a new client is created during protocol handshake.
"""
@callback created_client(client_id :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a client is destroyed - either by an explicit disconnect request
from the client, or by a system generated timeout.
"""
@callback destroyed_client(client_id :: binary, reason :: binary | atom, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a new channel is created - this happens when a client subscribes
to it for the first time.
"""
@callback created_channel(channel_name :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a channel is destroyed - this happens when the last client
unsubscribes from it.
"""
@callback destroyed_channel(channel_name :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a client subscribes to a channel.
"""
@callback client_subscribed(client_id :: binary, channel_name :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a client unsubscribes from a channel.
"""
@callback client_unsubscribed(client_id :: binary, channel_name :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a message is received with the ID of the message.
Some caveats:
- This function is only called when a publish message is received, not when
any protocol messages, such as connect or subscribe are received.
- Message IDs are only unique per client, not globally.
- If the message was generated on the server (ie via `Pixie.publish/2`) then
the Client ID is likely to be `nil`.
"""
@callback received_message(client_id :: binary, message_id :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
@doc """
Called when a message is delivered to a client.
Some caveats:
- This function is only called when a publish message is delivered, not when
any protocol messages, such as connect or subscribe are.
- Message IDs are only unique per client, not globally.
- The Client ID is that of the *sender*, not the receiver.
- If the message was generated on the server (ie via `Pixie.publish/2`) then
the Client ID is likely to be `nil`.
- You will likely receive a lot of delivered calls for each received call
as one message published to a channel may be relayed to thousands of
receivers.
"""
@callback delivered_message(client_id :: binary, message_id :: binary, at :: {megasecs :: integer, seconds :: integer, microsecs :: integer}) :: atom
def start_link handlers do
{:ok, pid} = GenEvent.start_link name: __MODULE__
Enum.each handlers, fn
{handler, args} ->
add_handler handler, args
handler ->
add_handler handler, []
end
{:ok, pid}
end
@doc """
Allows you to add a `Pixie.Monitor` or any other `GenEvent` handler to the
event stream. Expects the name of your handler module and any args which
you wish to be provided to your module's `init/1` callback.
"""
def add_handler handler, args \\ [] do
GenEvent.add_handler __MODULE__, handler, args
end
@doc """
Called by the backend when a new client is created either by protocol
handshake, or via `Pixie.subscribe/2`
"""
def created_client client_id do
GenEvent.notify __MODULE__, {:created_client, [client_id, Time.now]}
end
@doc """
Called by the backend when a client is destroyed, either by an expicit
protocol disconnect or for a system generated reason, such as a timeout.
"""
def destroyed_client client_id, reason \\ "Unknown reason" do
GenEvent.notify __MODULE__, {:destroyed_client, [client_id, reason, Time.now]}
end
@doc """
Called by the backend when a new channel is created.
New channels are created when the first client subscribes to them.
"""
def created_channel channel_name do
GenEvent.notify __MODULE__, {:created_channel, [channel_name, Time.now]}
end
@doc """
Called by the backend when a channel is destroyed.
Channels are destroyed when the last client unsubscribes from them.
"""
def destroyed_channel channel_name do
GenEvent.notify __MODULE__, {:destroyed_channel, [channel_name, Time.now]}
end
@doc """
Called by the backend when a client subscribes to a channel.
"""
def client_subscribed client_id, channel_name do
GenEvent.notify __MODULE__, {:client_subscribed, [client_id, channel_name, Time.now]}
end
@doc """
Called by the backend when a client unsubscribes from a channel.
"""
def client_unsubscribed client_id, channel_name do
GenEvent.notify __MODULE__, {:client_unsubscribed, [client_id, channel_name, Time.now]}
end
@doc """
Called whenever a new message is received for publication.
This includes server-generated messages using `Pixie.publish/2`
"""
def received_message %Pixie.Message.Publish{client_id: client_id, id: message_id} do
GenEvent.notify __MODULE__, {:received_message, [client_id, message_id, Time.now]}
end
def received_message(_), do: :ok
@doc """
Called by adapters when a message is finally delivered to a client.
"""
def delivered_message %Pixie.Message.Publish{client_id: client_id, id: message_id} do
GenEvent.notify __MODULE__, {:delivered_message, [client_id, message_id, Time.now]}
end
def delivered_message(_), do: :ok
end
|
lib/pixie/monitor.ex
| 0.839537 | 0.506103 |
monitor.ex
|
starcoder
|
defmodule Dirwalk do
@moduledoc """
A simple-to-use module to help traverse directories. Interface inspired by Python's `os.walk`.
`Dirwalk` enables you to walk directories lazily or greedily. Lazy traversal means that the minimum
amount of work is needed to get the next result, and each next step has to be done explicitly.
You must provide a startpoint, which is a path on the filesystem. `Dirwalk` will then
recursively walk across and down subdirectories.
Symlink and error handling are included. See `Dirwalk.walk` options for alternatives to the
top-down, depth-first walk done by default.
The data structure used is a triple / 3-tuple consisting of the current directory, and the
subdirectories and files in that directory.
In the most raw form, you can use `Dirwalk.walk`, and manually call the continuation function
when you want to consume the next result. This gives you control of how much to do.
## Using `walk` (see `testdirs` structure in this repo as an example)
iex> {{"testdirs", ["dogs", "cats", "felines"], []}, next} = Dirwalk.walk("testdirs")
iex> {{"testdirs/dogs", ["wild", "domestic"], []}, _next} = next.()
You can also use the struct based approach to simplify this a bit.
## Using helper functions
iex> dirwalk = Dirwalk.new("testdirs") |> Dirwalk.next()
iex> Dirwalk.results(dirwalk)
[{"testdirs", ["dogs", "cats", "felines"], []}]
But because `Dirwalk` implements `Enumerable`, it is probably easier to use `Enum` functions.
This allows for greedy traversal too.
## Using `Enum` functions
iex> Dirwalk.new("testdirs") |> Enum.take(1)
[{"testdirs", ["dogs", "cats", "felines"], []}]
"""
@type path :: String.t()
@type dirs :: [String.t()]
@type files :: [String.t()]
@type dirlist :: {path, dirs, files}
@type opts :: []
@type t :: %__MODULE__{}
defstruct [:next, results: [], done: false]
@doc """
Initialises a `Dirwalk` struct. Options are passed through and are the same as in `Dirwalk.walk`
"""
@spec new(binary, list) :: Dirwalk.t()
def new(root, opts \\ []) when is_binary(root) do
%Dirwalk{next: fn -> Dirwalk.walk(root, opts) end}
end
@doc """
Does the next traversal in the file tree. Stores result and handles completion
"""
@spec next(Dirwalk.t()) :: Dirwalk.t()
def next(%Dirwalk{next: next, results: results} = dirwalk) do
case next.() do
:done -> %Dirwalk{dirwalk | done: true}
{dirlist, next} -> %Dirwalk{dirwalk | next: next, results: [dirlist | results]}
end
end
@doc """
Returns whether traversal has finished.
"""
@spec done?(Dirwalk.t()) :: boolean
def done?(%Dirwalk{done: done}), do: done
@doc """
Returns accumulated results from the traversal.
"""
@spec results(Dirwalk.t()) :: [dirlist]
def results(%Dirwalk{results: results}), do: Enum.reverse(results)
@doc """
Returns last accumulated result.
"""
@spec last(Dirwalk.t()) :: nil | :done | dirlist
def last(%Dirwalk{results: []}), do: nil
def last(%Dirwalk{results: [head | _tail]}), do: head
defimpl Enumerable, for: __MODULE__ do
def count(_dirwalk), do: {:error, __MODULE__}
def member?(_dirwalk, _value), do: {:error, __MODULE__}
def slice(_dirwalk), do: {:error, __MODULE__}
def reduce(_dirwalk, {:halt, acc}, _fun), do: {:halted, acc}
def reduce(%Dirwalk{} = dirwalk, {:suspend, acc}, fun) do
{:suspended, acc, &reduce(dirwalk, &1, fun)}
end
def reduce(%Dirwalk{} = dirwalk, {:cont, acc}, fun) do
dirwalk = Dirwalk.next(dirwalk)
if Dirwalk.done?(dirwalk) do
{:done, acc}
else
last = Dirwalk.last(dirwalk)
reduce(dirwalk, fun.(last, acc), fun)
end
end
end
@doc """
`walk` takes a directory path and lazily and recursively traverses directories from that root.
It returns a tuple, consisting of a triple of `{path, directories, files}`, and a `next` function
to be invoked when the next traversal needs to be done. When there are no more subdirectories
to handle, `:done` is returned.
The default behaviour is a depth-first, top-down walk - this can be configured.
By default errors are silently ignored, though an optional handler can be passed in.
## Options:
- `:on_error`: optional 1- or 2-arity callback that is invoked with either `path` and `error`
or a tuple of `{path, error}` when an error occurs
- `:depth_first`: unless `false`, the walk is depth-first, otherwise breadth-first
- `:top_down`: unless `false`, the traversal is top-down.
## Examples (see `testdirs` structure)
# Top-down, depth-first
iex> {{"testdirs", ["dogs", "cats", "felines"], []}, next} = Dirwalk.walk("testdirs")
iex> {{"testdirs/dogs", ["wild", "domestic"], []}, _next} = next.()
# Bottom-up
iex> {{"testdirs/dogs/wild", [], ["coyote.txt", "wolf.txt"]}, next} = \
Dirwalk.walk("testdirs", top_down: false)
iex> {{"testdirs/dogs/domestic", [], ["dog.txt"]}, _next} = next.()
# Breadth-first
iex> {{"testdirs", ["dogs", "cats", "felines"], []}, next} = Dirwalk.walk("testdirs", depth_first: false)
iex> {{"testdirs/dogs", ["wild", "domestic"], []}, next} = next.()
iex> {{"testdirs/cats", ["wild", "domestic"], []}, _next} = next.()
"""
@spec walk(path, opts) :: {dirlist, (() -> any())} | :done
def walk(path, opts \\ []) do
on_error = Keyword.get(opts, :on_error)
depth_first = !!Keyword.get(opts, :depth_first, true)
top_down = !!Keyword.get(opts, :top_down, true)
follow_symlinks = !!Keyword.get(opts, :follow_symlinks, false)
opts = %{
top_down: top_down,
depth_first: depth_first,
follow_symlinks: follow_symlinks,
on_error: on_error
}
do_walk([path], opts, fn -> :done end)
end
defp do_walk([], _opts, next), do: next.()
defp do_walk(
[path | remaining_dirs],
%{on_error: on_error, follow_symlinks: follow_symlinks} = opts,
next
) do
if should_list?(path, follow_symlinks) do
case get_dirs_and_files(path, on_error) do
{:ok, {dirs, files}} ->
child_dirs = build_child_paths(dirs, path)
{next_dirs, next_fun} =
prepare_continuation({path, dirs, files}, child_dirs, remaining_dirs, opts, next)
do_walk(next_dirs, opts, next_fun)
:error ->
do_walk(remaining_dirs, opts, next)
end
else
do_walk(remaining_dirs, opts, next)
end
end
defp should_list?(_path, _follow_symlinks = true), do: true
defp should_list?(path, _follow_symlinks = false), do: not symlink?(path)
defp get_dirs_and_files(path, on_error) do
case partition_files(path) do
{:ok, results} ->
{:ok, results}
{:error, reason} ->
maybe_call_on_error(on_error, path, reason)
:error
end
end
defp partition_files(path) do
path
|> File.ls()
|> case do
{:ok, files} ->
{:ok, Enum.split_with(files, fn f -> path |> Path.join(f) |> File.dir?() end)}
{:error, _reason} = error ->
error
end
end
defp build_child_paths(dirs, path), do: Enum.map(dirs, &Path.join(path, &1))
defp prepare_continuation(
dirlist,
child_dirs,
remaining_dirs,
%{top_down: true, depth_first: true} = opts,
next
) do
# Top-down: yield this directory listing first, before recursing on children and siblings
next_fun = fn ->
{dirlist, fn -> do_walk(child_dirs ++ remaining_dirs, opts, next) end}
end
{[], next_fun}
end
defp prepare_continuation(
dirlist,
child_dirs,
remaining_dirs,
%{top_down: true, depth_first: false} = opts,
next
) do
next_fun = fn ->
{dirlist, fn -> do_walk(remaining_dirs ++ child_dirs, opts, next) end}
end
{[], next_fun}
end
defp prepare_continuation(dirlist, child_dirs, remaining_dirs, %{top_down: false} = opts, next) do
# Bottom-up: recurse on children dirs first, before yielding this directory's results
# and only then recurse on siblings
next_fun = fn ->
{dirlist,
fn ->
do_walk(remaining_dirs, opts, next)
end}
end
{child_dirs, next_fun}
end
defp maybe_call_on_error(on_error, path, reason) when is_function(on_error, 2) do
on_error.(path, reason)
end
defp maybe_call_on_error(on_error, path, reason) when is_function(on_error, 1) do
on_error.({path, reason})
end
defp maybe_call_on_error(_on_error, _path, _reason), do: nil
defp symlink?(path) do
case File.lstat(path) do
{:ok, %File.Stat{type: :symlink}} ->
true
{:ok, _file_stat} ->
false
{:error, _reason} ->
# Error handling will have already been done
false
end
end
end
|
lib/dirwalk.ex
| 0.921313 | 0.589716 |
dirwalk.ex
|
starcoder
|
defmodule Mix.Tasks.Format do
use Mix.Task
@shortdoc "Formats the given files/patterns"
@moduledoc """
Formats the given files and patterns.
mix format mix.exs "lib/**/*.{ex,exs}" "test/**/*.{ex,exs}"
Formatting is done with the `Code.format_string/2` function.
## Options
* `--check-formatted` - check that the file is already formatted.
This is useful in pre-commit hooks and CI scripts if you want to
reject contributions with unformatted code. However, keep in mind,
that the formatting output may differ between Elixir versions as
improvements and fixes are applied to the formatter.
* `--check-equivalent` - check if the file after formatting has the
same AST. If the ASTs are not equivalent, it is a bug in the code
formatter. This option is recommended if you are automatically
formatting files.
* `--dry-run` - do not save files after formatting.
* `--print` - write formatted files to stdout instead of saving to disk.
* `--dot-formatter` - the file with formatter configuration.
Defaults to `.formatter.exs` if one is available, see next section.
If any of the `--check-*` flags are given and a check fails, the formatted
contents won't be written to disk nor printed to stdout (if the `--print`
flag is given).
## .formatter.exs
The formatter will read a `.formatter.exs` in the current directory for
formatter configuration. It should return a keyword list with any of the
options supported by `Code.format_string!/2`.
The `.formatter.exs` also supports an `:inputs` field which specifies the
default inputs to be used by this task.
## When to format code
We recommend developers to format code directly in their editors. Either
automatically on save or via an explicit command/key binding. If such option
is not yet available in your editor of choice, adding the required integration
is relatively simple as it is a matter of invoking
cd $project && mix format $file
where `$file` refers to the current file and `$project` is the root of your
project.
It is also possible to format code across the whole project by passing a list
of patterns and files to `mix format`, as showed at the top of this task
documentation. This list can also be set in the `.formatter.exs` under the
`:inputs` key.
"""
@switches [
check_equivalent: :boolean,
check_formatted: :boolean,
dot_formatter: :string,
dry_run: :boolean,
print: :boolean
]
def run(args) do
{opts, args} = OptionParser.parse!(args, strict: @switches)
formatter_opts = eval_dot_formatter(opts)
args
|> expand_args(formatter_opts)
|> Enum.reduce({[], []}, &format_file(&1, &2, opts, formatter_opts))
|> check!()
end
defp eval_dot_formatter(opts) do
case dot_formatter(opts) do
{:ok, dot_formatter} ->
{formatter_opts, _} = Code.eval_file(dot_formatter)
unless Keyword.keyword?(formatter_opts) do
Mix.raise(
"Expected #{inspect(dot_formatter)} to return a keyword list, " <>
"got: #{inspect(formatter_opts)}"
)
end
formatter_opts
:error ->
[]
end
end
defp dot_formatter(opts) do
cond do
dot_formatter = opts[:dot_formatter] -> {:ok, dot_formatter}
File.regular?(".formatter.exs") -> {:ok, ".formatter.exs"}
true -> :error
end
end
defp expand_args([], formatter_opts) do
if inputs = formatter_opts[:inputs] do
expand_files_and_patterns(List.wrap(inputs), ".formatter.exs")
else
Mix.raise(
"Expected one or more files/patterns to be given to mix format " <>
"or for a .formatter.exs to exist with an :inputs key"
)
end
end
defp expand_args(files_and_patterns, _formatter_opts) do
expand_files_and_patterns(files_and_patterns, "command line")
end
defp expand_files_and_patterns(files_and_patterns, context) do
files_and_patterns
|> Enum.flat_map(fn file_or_pattern ->
files = Path.wildcard(file_or_pattern)
cond do
files != [] ->
files
File.regular?(file_or_pattern) ->
[file_or_pattern]
true ->
Mix.raise(
"Pattern #{inspect(file_or_pattern)} from #{context} " <>
"does not expand to any existing file"
)
end
end)
|> Enum.uniq()
end
defp format_file(file, {not_equivalent, not_formatted}, task_opts, formatter_opts) do
input = File.read!(file)
output = [Code.format_string!(input, formatter_opts), ?\n]
check_equivalent? = Keyword.get(task_opts, :check_equivalent, false)
check_formatted? = Keyword.get(task_opts, :check_formatted, false)
dry_run? = Keyword.get(task_opts, :dry_run, false)
print? = Keyword.get(task_opts, :print, false)
{valid?, not_equivalent, not_formatted} =
if check_equivalent? or check_formatted? do
output_string = IO.iodata_to_binary(output)
cond do
check_equivalent? and not equivalent?(input, output_string) ->
{false, [file | not_equivalent], not_formatted}
check_formatted? and input != output_string ->
{false, not_equivalent, [file | not_formatted]}
true ->
{not check_formatted?, not_equivalent, not_formatted}
end
else
{true, not_equivalent, not_formatted}
end
cond do
not valid? or dry_run? -> :ok
print? -> IO.write(output)
true -> File.write!(file, output)
end
{not_equivalent, not_formatted}
end
defp check!({[], []}) do
:ok
end
defp check!({[], not_formatted}) do
Mix.raise("""
mix format failed due to --check-formatted.
The following files were not formatted:
#{to_bullet_list(not_formatted)}
""")
end
defp check!({not_equivalent, []}) do
Mix.raise("""
mix format failed due to --check-equivalent.
The following files were not equivalent:
#{to_bullet_list(not_equivalent)}
Please report this bug with the input files at github.com/elixir-lang/elixir/issues
""")
end
defp to_bullet_list(files) do
Enum.map_join(files, "\n", &[" * ", &1])
end
defp equivalent?(input, output) do
Code.Formatter.equivalent(input, output) == :ok
end
end
|
lib/mix/lib/mix/tasks/format.ex
| 0.804598 | 0.445288 |
format.ex
|
starcoder
|
defmodule JID do
@moduledoc """
Jabber Identifiers (JIDs) uniquely identify individual entities in an XMPP
network.
A JID often resembles an email address with a user@host form, but there's
a bit more to it. JIDs consist of three main parts:
A JID can be composed of a local part, a server part, and a resource part.
The server part is mandatory for all JIDs, and can even stand alone
(e.g., as the address for a server).
The combination of a local (user) part and a server is called a "bare JID",
and it is used to identitfy a particular account on a server.
A JID that includes a resource is called a "full JID", and it is used to
identify a particular client connection (i.e., a specific connection for the
associated "bare JID" account).
This module implements the `to_string/1` for the `String.Chars` protocol for
returning a binary string from the `JID` struct.
Returns a string representation from a JID struct.
## Examples
iex> to_string(%JID{user: "romeo", server: "montague.lit", resource: "chamber"})
"[email protected]/chamber"
iex> to_string(%JID{user: "romeo", server: "montague.lit"})
"<EMAIL>"
iex> to_string(%JID{server: "montague.lit"})
"montague.lit"
"""
alias JID
defmodule JIDParsingError do
@moduledoc false
defexception [:message]
def exception(msg) do
%JIDParsingError{message: "JID parsing failed with #{inspect msg}"}
end
end
@type t :: %__MODULE__{}
@derive Jason.Encoder
defstruct user: "", server: "", resource: "", full: ""
defimpl String.Chars, for: JID do
def to_string(%JID{user: "", server: server, resource: ""}), do: server
def to_string(%JID{user: user, server: server, resource: ""}) do
user <> "@" <> server
end
def to_string(%JID{user: user, server: server, resource: resource}) do
user <> "@" <> server <> "/" <> resource
end
end
@doc """
Returns a binary JID without a resource.
## Examples
iex> JID.bare(%JID{user: "romeo", server: "montague.lit", resource: "chamber"})
"<EMAIL>"
iex> JID.bare("[email protected]/chamber")
"<EMAIL>"
"""
@spec bare(jid :: binary | JID.t) :: binary
def bare(jid) when is_binary(jid), do: parse(jid) |> bare
def bare(%JID{} = jid), do: to_string(%JID{jid | resource: ""})
@spec user(jid :: binary | JID.t) :: binary
def user(jid) when is_binary(jid), do: parse(jid).user
def user(%JID{user: user}), do: user
@spec server(jid :: binary | JID.t) :: binary
def server(jid) when is_binary(jid), do: parse(jid).server
def server(%JID{server: server}), do: server
@spec resource(jid :: binary | JID.t) :: binary
def resource(jid) when is_binary(jid), do: parse(jid).resource
def resource(%JID{resource: resource}), do: resource
@spec parse(jid :: nil) :: JIDParsingError
def parse(string = nil), do: raise JIDParsingError, message: string
@doc """
Parses a binary string JID into a JID struct.
## Examples
iex> JID.parse("<EMAIL>[email protected]/chamber")
%JID{user: "romeo", server: "montague.lit", resource: "chamber", full: "[email protected]/chamber"}
iex> JID.parse("<EMAIL>")
%JID{user: "romeo", server: "montague.lit", resource: "", full: "<EMAIL>"}
"""
@spec parse(jid :: binary) :: JID.t
def parse(string) do
case String.split(string, ["@", "/"], parts: 3) do
[user, server, resource] ->
%JID{user: user, server: server, resource: resource, full: string}
[user, server] ->
%JID{user: user, server: server, full: string}
[server] ->
%JID{server: server, full: string}
end
end
end
|
lib/jid.ex
| 0.864982 | 0.61315 |
jid.ex
|
starcoder
|
defmodule Sanity.Components.PortableText do
@moduledoc ~S'''
For rending [Sanity CMS portable text](https://www.sanity.io/docs/presenting-block-text).
## Examples
### Basic example
use Phoenix.Component
# ...
assigns = %{
portable_text: [
%{
_key: "f71173c80e3a",
_type: "block",
children: [%{_key: "<KEY>", _type: "span", marks: [], text: "Test paragraph."}],
mark_defs: [],
style: "normal"
}
]
}
~H"<Sanity.Components.PortableText.portable_text value={@portable_text} />"
### Custom rendering
defmodule CustomBlock do
use Phoenix.Component
use Sanity.Components.PortableText
@impl true
def block(%{value: %{style: "normal"}} = assigns) do
~H"""
<div class="custom-normal"><%= render_slot(@inner_block) %></div>
"""
end
def block(assigns), do: super(assigns)
end
Then render the component like:
~H"<Sanity.Components.PortableText.portable_text mod={CustomBlock} value={@portable_text} />"
Similarly, marks and types can be customized by defining `mark/1` and `type/1` functions in the module.
'''
use Phoenix.Component
require Logger
defmodule Behaviour do
@moduledoc false
@callback block(map()) :: Phoenix.LiveView.Rendered.t()
@callback mark(map()) :: Phoenix.LiveView.Rendered.t()
@callback type(map()) :: Phoenix.LiveView.Rendered.t()
end
@behaviour Behaviour
defmacro __using__([]) do
quote do
@behaviour Sanity.Components.PortableText.Behaviour
def block(assigns), do: Sanity.Components.PortableText.block(assigns)
def mark(assigns), do: Sanity.Components.PortableText.mark(assigns)
def type(assigns), do: Sanity.Components.PortableText.type(assigns)
defoverridable Sanity.Components.PortableText.Behaviour
end
end
@doc """
Renders Sanity CMS portable text. See module doc for examples.
"""
def portable_text(assigns) do
mod = Map.get(assigns, :mod, __MODULE__)
~H"""
<%= for group <- blocks_to_nested_lists(@value) do %><.blocks_or_list mod={mod} value={group} /><% end %>
"""
end
defp blocks_to_nested_lists(blocks) do
blocks
|> Enum.chunk_by(fn block -> block[:list_item] end)
|> Enum.map(fn
[%{list_item: list_item} | _] = items when not is_nil(list_item) ->
nest_list(items, %{type: list_item, level: 1, items: []})
[%{} | _] = blocks ->
%{type: "blocks", items: blocks}
end)
end
defp nest_list([], acc) do
update_in(acc.items, &Enum.reverse/1)
end
defp nest_list([%{level: level} = item | rest], %{level: level} = acc) do
nest_list(rest, prepend_to_list(item, acc))
end
defp nest_list([%{level: level, list_item: list_item} | _] = items, acc)
when level > acc.level do
{deeper_items, rest} = Enum.split_while(items, fn i -> i.level > acc.level end)
sub_list = nest_list(deeper_items, %{type: list_item, level: acc.level + 1, items: []})
acc =
case acc do
%{items: [last_item | acc_rest]} ->
put_in(acc.items, [Map.put(last_item, :sub_list, sub_list) | acc_rest])
%{items: []} ->
empty_list_block(%{level: acc.level + 1, list_item: acc.type})
|> Map.put(:sub_list, sub_list)
|> prepend_to_list(acc)
end
nest_list(rest, acc)
end
defp empty_list_block(%{level: level, list_item: list_item}) do
%{
_key: :crypto.strong_rand_bytes(6) |> Base.encode16(case: :lower),
_type: "block",
children: [],
level: level,
list_item: list_item,
mark_defs: [],
style: "normal"
}
end
defp prepend_to_list(item, %{items: items} = list), do: %{list | items: [item | items]}
defp render_with(assigns) do
{func, assigns} = Map.pop!(assigns, :func)
apply(assigns.mod, func, [assigns])
end
defp shared_props(assigns), do: Map.take(assigns, [:mod, :value])
defp blocks_or_list(%{value: %{type: "blocks"}} = assigns) do
~H"""
<%= for block <- @value.items do %>
<.render_with mod={@mod} func={:type} value={block} />
<% end %>
"""
end
defp blocks_or_list(%{value: %{type: "bullet"}} = assigns) do
~H"""
<ul>
<%= for item <- @value.items do %>
<.list_item mod={@mod} value={item} />
<% end %>
</ul>
"""
end
defp blocks_or_list(%{value: %{type: "number"}} = assigns) do
~H"""
<ol>
<%= for item <- @value.items do %>
<.list_item mod={@mod} value={item} />
<% end %>
</ol>
"""
end
defp list_item(assigns) do
~H"""
<li>
<.children {shared_props(assigns)} />
<%= if @value[:sub_list] do %><.blocks_or_list mod={@mod} value={@value.sub_list} /><% end %>
</li>
"""
end
defp children(assigns) do
~H"""
<%= for child <- @value.children do %><.marks marks={child.marks} {shared_props(assigns)}><%= child.text %></.marks><% end %>
"""
end
@doc false
@impl true
def type(%{value: %{_type: "block"}} = assigns) do
~H"""
<.render_with func={:block} {shared_props(assigns)}>
<.children {shared_props(assigns)} />
</.render_with>
"""
end
def type(%{value: %{_type: type}} = assigns) do
Logger.error("unknown type: #{inspect(type)}")
~H""
end
@doc false
@impl true
def block(%{value: %{_type: "block", style: style}} = assigns)
when style in ["blockquote", "h1", "h2", "h3", "h4", "h5", "h6"] do
~H"""
<%= Phoenix.HTML.Tag.content_tag style do %><%= render_slot(@inner_block) %><% end %>
"""
end
def block(%{value: %{_type: "block", style: "normal"}} = assigns) do
~H"""
<p><%= render_slot(@inner_block) %></p>
"""
end
def block(%{value: %{_type: "block", style: style}} = assigns) do
Logger.error("unknown block style: #{inspect(style)}")
~H"""
<p><%= render_slot(@inner_block) %></p>
"""
end
defp marks(%{marks: []} = assigns) do
~H"""
<%= render_slot(@inner_block) %>
"""
end
defp marks(%{marks: [mark | remaining_marks]} = assigns) do
mark_props =
case Enum.find(assigns.value.mark_defs, &(&1._key == mark)) do
nil ->
%{
mark_key: mark,
mark_type: mark,
value: nil
}
%{_type: type} = mark_def ->
%{
mark_key: mark,
mark_type: type,
value: mark_def
}
end
~H"""
<.render_with mod={@mod} func={:mark} {mark_props}><.marks marks={remaining_marks} {shared_props(assigns)}><%= render_slot(@inner_block) %></.marks></.render_with>
"""
end
@doc false
@impl true
def mark(%{mark_type: "em"} = assigns) do
~H"""
<em><%= render_slot(@inner_block) %></em>
"""
end
def mark(%{mark_type: "strong"} = assigns) do
~H"""
<strong><%= render_slot(@inner_block) %></strong>
"""
end
def mark(%{mark_type: "link", value: value} = assigns) do
~H"""
<a href={value.href}><%= render_slot(@inner_block) %></a>
"""
end
def mark(%{mark_type: mark_type} = assigns) do
Logger.error("unknown mark type: #{inspect(mark_type)}")
~H"""
<%= render_slot(@inner_block) %>
"""
end
end
|
lib/sanity/components/portable_text.ex
| 0.754915 | 0.506897 |
portable_text.ex
|
starcoder
|
defmodule CRUDimentary.Absinthe.Generator.Endpoint do
@moduledoc """
This module defines generators for Absinthe GraphQL CRUD fields.
By calling one of macros you can generate multiple queries or mutations with generic resolver callbacks, middleware and error handlers.
"""
import CRUDimentary.Absinthe.Generator.ResultType
@query_types [:index, :show]
@mutation_types [:create, :update, :destroy]
@error_handler Confex.get_env(CRUDimentary.MixProject.project()[:app], :error_handler)
@doc """
Generates Absinthe schema query CRUD (index and show) fields based uppon options.
```
query do
CRUDimentary.Absinthe.EndpointGenerator.generic_query(
:account,
Project.API.Resolvers.Account,
[
error_handler: ErrorHandler,
index: [
middleware:
[
before: [Middleware, Middleware],
after: [Middleware]
]
]
])
end
```
This results in generated fields:
```
RootQueryType{
account(id: ID!): AccountSingleResult
accounts(
filter: [AccountFilter]
pagination: PaginationInput
sorting: AccountSorting): AccountListResult
}
```
"""
defmacro generic_query(name, base_module, options \\ %{}) do
for query_type <- @query_types do
if included?(query_type, options) do
quote do
unquote(__MODULE__).generic_schema_field(
unquote(query_type),
unquote(name),
nil,
String.to_atom("#{unquote(name)}_filter"),
String.to_atom("#{unquote(name)}_sorting"),
unquote(base_module),
unquote(options)
)
end
end
end
end
@doc """
Generates Absinthe schema mutation CRUD (create, update, destory) fields based uppon options.
```
mutation do
CRUDimentary.Absinthe.EndpointGenerator.generic_mutation(
:account,
Project.API.Resolvers.Account,
[
exclude: [:update]
])
end
```
This results in generated fields:
```
RootMutationType{
createAccount(input: AccountInput!): AccountSingleResult
destroyAccount(id: ID!): AccountSingleResult
}
```
"""
defmacro generic_mutation(name, base_module, options \\ %{}) do
for mutation_type <- @mutation_types do
if included?(mutation_type, options) do
quote do
unquote(__MODULE__).generic_schema_field(
unquote(mutation_type),
unquote(name),
String.to_atom("#{unquote(name)}_input"),
nil,
nil,
unquote(base_module),
unquote(options)
)
end
end
end
end
@doc false
defmacro generic_schema_field(
action_type,
name,
input_type,
filter_type,
sort_type,
base_module,
options
) do
error_handler = options[:error_handler] || @error_handler
quote do
@desc unquote(generate_description(name, action_type))
field(
unquote(action_name(name, action_type, options)),
unquote(
case action_type do
:index ->
result_name(name, :list)
_ ->
result_name(name, :single)
end
)
) do
unquote(
case action_type do
:index ->
quote do
arg(:filter, list_of(unquote(filter_type)))
arg(:sorting, unquote(sort_type))
arg(:pagination, :pagination_input)
end
:create ->
quote do
arg(:input, non_null(unquote(input_type)))
end
:update ->
quote do
arg(:id, non_null(:id))
arg(:input, non_null(unquote(input_type)))
end
_ ->
quote do
arg(:id, non_null(:id))
end
end
)
unquote(
for mw <- extract_middleware(action_type, :before, options) do
quote do
middleware(unquote(mw))
end
end
)
resolve(
&Module.concat(unquote(base_module), unquote(capitalize_atom(action_type))).call/3
)
unquote(
if error_handler do
quote do
middleware(unquote(error_handler))
end
end
)
unquote(
for mw <- extract_middleware(action_type, :after, options) do
quote do
middleware(unquote(mw))
end
end
)
end
end
end
@doc false
def generate_description(name, :index),
do: "Fetches filtered and sorted list of #{name} resources"
def generate_description(name, :show), do: "Fetches single #{name} resource by id"
def generate_description(name, :create), do: "Creates new #{name} resource"
def generate_description(name, :update), do: "Updates existing #{name} resource by id"
def generate_description(name, :destroy), do: "Deletes #{name} resource by id"
@doc false
def included?(action, options) do
!excluded?(action, options)
end
@doc false
def excluded?(action, options) do
exclusions = options[:except] || options[:exclude] || []
included = options[:only] || []
Enum.member?(exclusions, action) || (Enum.any?(included) && !Enum.member?(included, action))
end
@doc false
def extract_middleware(action, position, options) do
(options[action][:middleware][position] || []) ++ (options[:middleware][position] || [])
end
@doc false
def filter_name(name) do
String.to_atom("#{name}_filter")
end
@doc false
def index_name(name) do
"#{name}"
|> Inflex.pluralize()
|> String.to_atom()
end
@doc false
def action_name(name, :show, options) do
extract_action_name(:show, options) || name
end
def action_name(name, :index, options) do
extract_action_name(:index, options) || index_name(name)
end
def action_name(name, action, options) do
extract_action_name(action, options) || String.to_atom("#{action}_#{name}")
end
@doc false
def extract_action_name(action, options) do
options[:name][action]
end
@doc false
def capitalize_atom(atom) do
atom
|> Atom.to_string()
|> String.capitalize()
|> String.to_atom()
end
end
|
lib/crudimentary/absinthe/generators/endpoint.ex
| 0.728941 | 0.612339 |
endpoint.ex
|
starcoder
|
defmodule Plymio.Fontais.Option do
@moduledoc ~S"""
Functions for Managing Keyword Options ("opts")
See `Plymio.Fontais` for overview and other documentation terms.
## Documentation Terms
### *key*
A *key* is an `Atom`.
### *key list*
A *key list* is a list of *key*s.
### *key spec*
A *key spec* is usually a *key list*.
Alternatively a `Map` with `Atom` keys or a `Keyword` can be given and the (unique) keys will be used.
### *key alias dict*
A *key alias dict* is usually a `Map` with `Atom` keys and values used for canonicalising keys (e.g. as the 2nd argument to `opts_canonical_keys/2`).
Alternatively a `Keyword` with `Atom` values can be given and will be converted on the fly.
### *key dict*
A *key alias dict* is usually a `Map` with `Atom` keys.
Alternatively a `Keyword` with `Atom` values can be given and will be converted on the fly.
"""
use Plymio.Fontais.Attribute
@type key :: Plymio.Fontais.key()
@type keys :: Plymio.Fontais.keys()
@type opts :: Plymio.Fontais.opts()
@type opzioni :: Plymio.Fontais.opzioni()
@type error :: Plymio.Fontais.error()
@type result :: Plymio.Fontais.result()
@type aliases_tuples :: Plymio.Fontais.aliases_tuples()
@type aliases_kvs :: Plymio.Fontais.aliases_kvs()
@type aliases_dict :: Plymio.Fontais.aliases_dict()
import Plymio.Fontais.Error,
only: [
new_error_result: 1,
new_argument_error_result: 1,
new_key_error_result: 2,
new_bad_key_error_result: 2
]
import Plymio.Fontais.Utility,
only: [
validate_key: 1
]
import Plymio.Fontais.Option.Utility,
only: [
normalise_key_alias_dict: 1,
normalise_key_list: 1,
normalise_key_dict: 1
]
@doc ~S"""
`opts_normalise/` expects a *derivable opts* and returns `{:ok, opts}`.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opts_normalise
{:ok, []}
iex> %{a: 1, b: 2, c: 3} |> opts_normalise
{:ok, [a: 1, b: 2, c: 3]}
iex> {:error, error} = %{"a" => 1, :b => 2, :c => 3} |> opts_normalise
...> error |> Exception.message
"bad key \"a\" for: %{:b => 2, :c => 3, \"a\" => 1}"
iex> {:error, error} = 42 |> opts_normalise
...> error |> Exception.message
"opts not derivable, got: 42"
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opts_normalise
{:ok, [a: nil, b: [:b1], c: [:c1, :c2, :c3]]}
"""
@since "0.1.0"
@spec opts_normalise(any) :: {:ok, opts} | {:error, error}
def opts_normalise(value) do
cond do
Keyword.keyword?(value) ->
{:ok, value}
is_map(value) ->
value
|> Map.to_list()
|> (fn tuples ->
tuples
|> Keyword.keyword?()
|> case do
true ->
{:ok, tuples}
_ ->
tuples
|> Keyword.keys()
|> Enum.reject(&is_atom/1)
|> new_bad_key_error_result(value)
end
end).()
true ->
new_error_result(m: @plymio_fontais_error_message_opts_not_derivable, v: value)
end
end
@doc ~S"""
`opts_validate/1` returns `{:ok, opts}` if the argument is an *opts*.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opts_validate
{:ok, []}
iex> %{a: 1, b: 2, c: 3} |> opts_validate
{:error, %ArgumentError{message: "opts invalid, got: %{a: 1, b: 2, c: 3}"}}
iex> %{"a" => 1, :b => 2, :c => 3} |> opts_validate
{:error, %ArgumentError{message: "opts invalid, got: %{:b => 2, :c => 3, \"a\" => 1}"}}
iex> 42 |> opts_validate
{:error, %ArgumentError{message: "opts invalid, got: 42"}}
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opts_validate
{:ok, [a: nil, b: [:b1], c: [:c1, :c2, :c3]]}
"""
@since "0.1.0"
@spec opts_validate(any) :: {:ok, opts} | {:error, error}
def opts_validate(value) do
case Keyword.keyword?(value) do
true -> {:ok, value}
_ -> new_error_result(m: @plymio_fontais_error_message_opts_invalid, v: value)
end
end
@doc ~S"""
`opts_merge/` takes one or more *derivable opts*, merges them and returns `{:ok, opts}`.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opts_merge
{:ok, []}
iex> [a: 1, b: 2, c: 3] |> opts_merge
{:ok, [a: 1, b: 2, c: 3]}
iex> [[a: 1], [b: 2], [c: 3]] |> opts_merge
{:ok, [a: 1, b: 2, c: 3]}
iex> %{a: 1, b: 2, c: 3} |> opts_merge
{:ok, [a: 1, b: 2, c: 3]}
iex> [%{a: 1, b: 2, c: 3}, [d: 4]] |> opts_merge
{:ok, [a: 1, b: 2, c: 3, d: 4]}
iex> {:error, error} = [[d: 4], %{"a" => 1, :b => 2, :c => 3}] |> opts_merge
...> error |> Exception.message
"bad key \"a\" for: %{:b => 2, :c => 3, \"a\" => 1}"
iex> {:error, error} = 42 |> opts_merge
...> error |> Exception.message
"opts not derivable, got: 42"
"""
@since "0.1.0"
@spec opts_merge(any) :: {:ok, opts} | {:error, error}
def opts_merge(value) do
cond do
Keyword.keyword?(value) ->
{:ok, value}
is_map(value) ->
value |> opts_normalise
is_list(value) ->
value
|> Enum.reduce_while(
[],
fn opts, collated_opts ->
with {:ok, new_opts} <- opts |> opts_normalise do
{:cont, collated_opts ++ new_opts}
else
{:error, %{__struct__: _}} = result -> {:halt, result}
end
end
)
|> case do
{:error, %{__struct__: _}} = result -> result
opts -> {:ok, opts}
end
true ->
new_error_result(m: @plymio_fontais_error_message_opts_not_derivable, v: value)
end
end
@doc ~S"""
`opts_canonical_keys/2` takes a *derivable opts*, together with a *key alias dict*.
Each key in the `opts` is replaced with its (canonical) value from the dictionary, returning `{:ok, canon_opts}`.
If there are any unknown keys, `{:error, error}`, where `error` is a `KeyError`, will be returned.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_canonical_keys(%{a: :x, b: :y, c: :z})
{:ok, [x: 1, y: 2, z: 3]}
iex> [a: 1, b: 2, c: 3] |> opts_canonical_keys([a: :x, b: :y, c: :z])
{:ok, [x: 1, y: 2, z: 3]}
iex> [a: 11, p: 1, b: 22, q: 2, c: 33, r: 3] |> opts_canonical_keys(%{a: :x, b: :y, c: :z})
{:error, %KeyError{key: [:p, :q, :r], term: %{a: :x, b: :y, c: :z}}}
iex> [a: 1, b: 2, c: 3] |> opts_canonical_keys([a_canon: :a, b_canon: [:b], c_canon: [:c, :cc]])
{:error, %ArgumentError{message: "expected valid key alias dictionary, got: %{a_canon: :a, b_canon: [:b], c_canon: [:c, :cc]}"}}
"""
@since "0.1.0"
@spec opts_canonical_keys(any, any) :: {:ok, opts} | {:error, error}
def opts_canonical_keys(opts, dict)
def opts_canonical_keys([], _dict) do
{:ok, []}
end
def opts_canonical_keys(opts, dict) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, dict} <- dict |> normalise_key_alias_dict do
opts
# reject known_keys
|> Enum.reject(fn {k, _v} -> Map.has_key?(dict, k) end)
|> case do
# no unknown keys
[] ->
canon_tuples =
opts
|> Enum.map(fn {k, v} -> {Map.get(dict, k), v} end)
{:ok, canon_tuples}
unknown_tuples ->
unknown_tuples |> new_key_error_result(dict)
end
else
{:error, _} = result -> result
end
end
@doc ~S"""
`opts_maybe_canonical_keys/2` takes a *derivable opts*, together with a *key alias dict*.
If an *opts* key exists in the dictionary, it is replaced with its (canonical) value. Otherwise the key is unchanged.
`{:ok, opts}` is returned.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_maybe_canonical_keys(%{a: :x, b: :y, c: :z})
{:ok, [x: 1, y: 2, z: 3]}
iex> [a: 11, p: 1, b: 22, q: 2, c: 33, r: 3]
...> |> opts_maybe_canonical_keys(%{a: :x, b: :y, c: :z})
{:ok, [x: 11, p: 1, y: 22, q: 2, z: 33, r: 3]}
"""
@since "0.1.0"
@spec opts_maybe_canonical_keys(any, any) :: {:ok, opts} | {:error, error}
def opts_maybe_canonical_keys(opts, dict) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, dict} <- dict |> normalise_key_alias_dict do
opts =
opts
|> Enum.map(fn {k, v} -> {Map.get(dict, k, k), v} end)
{:ok, opts}
else
{:error, _} = result -> result
end
end
@doc ~S"""
`opts_take_canonical_keys/2` takes a *derivable opts*, together with a *key alias dict*.
It first calls `opts_maybe_canonical_keys/2` to convert all known
keys to their canonical values, and then takes only the canonical keys returning `{:ok, opts}`.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_take_canonical_keys(%{a: :x, b: :y, c: :z})
{:ok, [x: 1, y: 2, z: 3]}
iex> [a: 11, p: 1, b: 22, q: 2, c: 33, r: 3]
...> |> opts_take_canonical_keys(%{a: :x, b: :y, c: :z})
{:ok, [x: 11, y: 22, z: 33]}
"""
@since "0.1.0"
@spec opts_take_canonical_keys(any, any) :: {:ok, opts} | {:error, error}
def opts_take_canonical_keys(opts, dict) do
with {:ok, dict} <- dict |> normalise_key_alias_dict,
{:ok, opts} <- opts |> opts_maybe_canonical_keys(dict) do
{:ok, opts |> Keyword.take(dict |> Map.values())}
else
{:error, _} = result -> result
end
end
@doc ~S"""
`canonical_keys/2` takes a *key list* and *key alias dict* and replaces each key with its canonical value from the dictionary, returning `{:ok, canonical_keys}`.
If there are any unknown keys `{:error, error}`, where `error` is a `KeyError`, will be returned.
## Examples
iex> [:a, :b, :c] |> canonical_keys(%{a: :p, b: :q, c: :r})
{:ok, [:p,:q,:r]}
iex> [:a, :b, :c] |> canonical_keys(%{a: 1, b: 2, c: 3})
{:ok, [1,2,3]}
iex> [:a, :x, :b, :y, :c, :z] |> canonical_keys(%{a: 1, b: 2, c: 3})
{:error, %KeyError{key: [:x, :y, :z], term: %{a: 1, b: 2, c: 3}}}
"""
@spec canonical_keys(any, any) :: {:ok, keys} | {:error, error}
def canonical_keys(keys, dict) do
with {:ok, keys} <- keys |> normalise_key_list,
{:ok, dict} <- dict |> normalise_key_dict do
keys
|> Enum.reject(fn k -> Map.has_key?(dict, k) end)
|> case do
# no unknown keys
[] ->
canon_keys = keys |> Enum.map(fn k -> dict |> Map.get(k) end)
{:ok, canon_keys}
unknown_keys ->
unknown_keys |> new_key_error_result(dict)
end
else
{:error, _} = result -> result
end
end
@doc ~S"""
`canonical_key/2` takes a key together with a *key dict* and replaces the key with its canonical value from the dictionary, returning `{:ok, canonical_key}`.
If the key is unknown, `{:error, error}`, `error` is a `KeyError`, will be returned.
## Examples
iex> :b |> canonical_key(%{a: :p, b: :q, c: :r})
{:ok, :q}
iex> :a |> canonical_key(%{a: 1, b: 2, c: 3})
{:ok, 1}
iex> :x |> canonical_key(%{a: 1, b: 2, c: 3})
{:error, %KeyError{key: :x, term: %{a: 1, b: 2, c: 3}}}
"""
@spec canonical_key(any, any) :: {:ok, key} | {:error, error}
def canonical_key(key, dict) do
with {:ok, key} <- key |> validate_key,
{:ok, keys} <- [key] |> canonical_keys(dict) do
{:ok, keys |> hd}
else
{:error, %KeyError{} = error} -> {:error, error |> struct!(key: key)}
{:error, _} = result -> result
end
end
@doc ~S"""
`opzioni_normalise/1` takes a value tries to normalise it into an *opzioni*, returning `{:ok, opzioni}`.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opzioni_normalise
{:ok, []}
iex> [a: 1, b: 2, c: 3] |> opzioni_normalise
{:ok, [[a: 1, b: 2, c: 3]]}
iex> %{a: 1, b: 2, c: 3} |> opzioni_normalise
{:ok, [[a: 1, b: 2, c: 3]]}
iex> [ [a: 1, b: 2, c: 3], %{x: 10, y: 11, z: 12}] |> opzioni_normalise
{:ok, [[a: 1, b: 2, c: 3], [x: 10, y: 11, z: 12]]}
iex> {:error, error} = %{"a" => 1, :b => 2, :c => 3} |> opzioni_normalise
...> error |> Exception.message
"bad key \"a\" for: %{:b => 2, :c => 3, \"a\" => 1}"
iex> {:error, error} = 42 |> opzioni_normalise
...> error |> Exception.message
"opzioni invalid, got: 42"
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opzioni_normalise
{:ok, [[a: nil, b: [:b1], c: [:c1, :c2, :c3]]]}
"""
@since "0.1.0"
@spec opzioni_normalise(any) :: {:ok, opts} | {:error, error}
def opzioni_normalise(opzioni \\ [])
def opzioni_normalise([]) do
{:ok, []}
end
def opzioni_normalise(opzioni) do
cond do
Keyword.keyword?(opzioni) ->
{:ok, [opzioni]}
is_list(opzioni) ->
opzioni
|> Enum.reduce_while([], fn
[], opzioni ->
{:cont, opzioni}
item, opzioni ->
with {:ok, new_opzioni} <- item |> opzioni_normalise do
{:cont, opzioni ++ new_opzioni}
else
{:error, %{__struct__: _}} = result -> {:halt, result}
end
end)
|> case do
{:error, %{__struct__: _}} = result ->
result
opzioni ->
{:ok, opzioni}
end
is_map(opzioni) ->
with {:ok, opts} <- opzioni |> opts_normalise do
{:ok, [opts]}
else
{:error, %{__exception__: true}} = result -> result
end
true ->
new_error_result(m: @plymio_fontais_error_message_opzioni_invalid, v: opzioni)
end
end
@doc ~S"""
`opzioni_validate/1` takes a value and validates it is an *opzioni*, returning `{:ok, opzioni}`.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opzioni_validate
{:ok, []}
iex> [[a: 1, b: 2, c: 3]] |> opzioni_validate
{:ok, [[a: 1, b: 2, c: 3]]}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opzioni_validate
...> error |> Exception.message
"opts invalid, got: {:a, 1}"
iex> {:error, error} = %{a: 1, b: 2, c: 3} |> opzioni_validate
...> error |> Exception.message
"opzioni invalid, got: %{a: 1, b: 2, c: 3}"
iex> {:error, error} = [[a: 1, b: 2, c: 3], %{x: 10, y: 11, z: 12}] |> opzioni_validate
...> error |> Exception.message
"opts invalid, got: %{x: 10, y: 11, z: 12}"
iex> {:error, error} = 42 |> opzioni_validate
...> error |> Exception.message
"opzioni invalid, got: 42"
"""
@since "0.1.0"
@spec opzioni_validate(any) :: {:ok, opts} | {:error, error}
def opzioni_validate(opzioni \\ [])
def opzioni_validate(opzioni) when is_list(opzioni) do
opzioni
|> Enum.reduce_while(
[],
fn opts, opzioni ->
opts
|> opts_validate
|> case do
{:ok, opts} ->
{:cont, [opts | opzioni]}
{:error, %{__struct__: _}} = result ->
{:halt, result}
end
end
)
|> case do
{:error, %{__exception__: true}} = result -> result
opzioni -> {:ok, opzioni |> Enum.reverse()}
end
end
def opzioni_validate(opzioni) do
new_argument_error_result("opzioni invalid, got: #{inspect(opzioni)}")
end
@doc ~S"""
`opzioni_merge/` takes one or more *opzioni*, normalises each one and merges them
to return `{:ok, opzioni}`.
Empty *opts* are removed.
Any other argument causes `{:error, error}` to be returned.
## Examples
iex> [] |> opzioni_merge
{:ok, []}
iex> [a: 1, b: 2, c: 3] |> opzioni_merge
{:ok, [[a: 1, b: 2, c: 3]]}
iex> [[a: 1], [b: 2], [c: 3]] |> opzioni_merge
{:ok, [[a: 1], [b: 2], [c: 3]]}
iex> [[[a: 1], [b: 2]], [c: 3], [[d: 4]]] |> opzioni_merge
{:ok, [[a: 1], [b: 2], [c: 3], [d: 4]]}
iex> [[a: 1], [], [b: 2], [], [c: 3]] |> opzioni_merge
{:ok, [[a: 1], [b: 2], [c: 3]]}
iex> %{a: 1, b: 2, c: 3} |> opzioni_merge
{:ok, [[a: 1, b: 2, c: 3]]}
iex> [%{a: 1, b: 2, c: 3}, [d: 4]] |> opzioni_merge
{:ok, [[a: 1, b: 2, c: 3], [d: 4]]}
iex> {:error, error} = [[d: 4], %{"a" => 1, :b => 2, :c => 3}] |> opzioni_merge
...> error |> Exception.message
"bad key \"a\" for: %{:b => 2, :c => 3, \"a\" => 1}"
iex> {:error, error} = 42 |> opzioni_merge
...> error |> Exception.message
"opzioni invalid, got: 42"
"""
@since "0.1.0"
@spec opzioni_merge(any) :: {:ok, opzioni} | {:error, error}
def opzioni_merge(opzioni)
def opzioni_merge(value) when is_list(value) do
value
|> opzioni_normalise
|> case do
{:ok, opzioni} ->
opzioni =
opzioni
|> Enum.filter(fn
[] -> false
_ -> true
end)
{:ok, opzioni}
_ ->
value
|> Enum.reduce_while(
[],
fn opzioni, opzionis ->
with {:ok, opzioni} <- opzioni |> opzioni_normalise do
{:cont, [opzioni | opzionis]}
else
{:error, %{__struct__: _}} = result -> {:halt, result}
end
end
)
|> case do
{:error, %{__struct__: _}} = result ->
result
opzionis ->
opzioni =
opzionis
|> Enum.reverse()
|> Enum.reduce([], fn v, s -> s ++ v end)
|> Enum.filter(fn
[] -> false
_ -> true
end)
{:ok, opzioni}
end
end
end
def opzioni_merge(value) when is_map(value) do
value |> Map.to_list() |> opzioni_merge
end
def opzioni_merge(opzioni) do
opzioni |> opzioni_validate
end
@doc ~S"""
`opzioni_flatten/1` takes a value, calls `opzioni_normalise/1` and then merges all the individual *opts* into a single *opts*.
## Examples
iex> [] |> opzioni_flatten
{:ok, []}
iex> [a: 1, b: 2, c: 3] |> opzioni_flatten
{:ok, [a: 1, b: 2, c: 3]}
iex> [[a: 1], [b: 2], [c: 3]] |> opzioni_flatten
{:ok, [a: 1, b: 2, c: 3]}
iex> [[a: 1], [[b: 2], [c: 3]]] |> opzioni_flatten
{:ok, [a: 1, b: 2, c: 3]}
iex> %{a: 1, b: 2, c: 3} |> opzioni_flatten
{:ok, [a: 1, b: 2, c: 3]}
iex> {:ok, opts} = [[a: 1, b: 2, c: 3], %{x: 10, y: 11, z: 12}] |> opzioni_flatten
...> opts |> Enum.sort
[a: 1, b: 2, c: 3, x: 10, y: 11, z: 12]
iex> {:error, error} = %{"a" => 1, :b => 2, :c => 3} |> opzioni_flatten
...> error |> Exception.message
"bad key \"a\" for: %{:b => 2, :c => 3, \"a\" => 1}"
iex> {:error, error} = 42 |> opzioni_flatten
...> error |> Exception.message
"opzioni invalid, got: 42"
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opzioni_flatten
{:ok, [a: nil, b: [:b1], c: [:c1, :c2, :c3]]}
"""
@since "0.1.0"
@spec opzioni_flatten(any) :: {:ok, opts} | {:error, error}
def opzioni_flatten(opzioni \\ [])
def opzioni_flatten([]) do
{:ok, []}
end
def opzioni_flatten(opzioni) do
opzioni
|> Keyword.keyword?()
|> case do
true ->
{:ok, opzioni}
_ ->
with {:ok, opzioni} <- opzioni |> opzioni_normalise do
{:ok, opzioni |> Enum.flat_map(& &1)}
else
{:error, %{__exception__: true}} = result -> result
end
end
end
@doc ~S"""
`opts_get/3` take a *derivable opts*, *key* and default and returns
the *last* value for the key (or default) as `{:ok, value_or_default}`.
Note this is different to `Keyword.get/3` that returns the *first* value.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_get(:a)
{:ok, 1}
iex> [a: 11, b: 21, c: 31, a: 12, b: 22, c: 32, a: 13, b: 23, c: 33] |> opts_get(:c)
{:ok, 33}
iex> [a: 1, b: 2, c: 3] |> opts_get(:d, 4)
{:ok, 4}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_get("a")
...> error |> Exception.message
"key invalid, got: a"
iex> {:error, error} = 42 |> opts_get(:a)
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_get(:a)
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_get(any, any, any) :: {:ok, any} | {:error, error}
def opts_get(opts, key, default \\ nil) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, key} <- key |> validate_key do
{:ok, opts |> Enum.reverse() |> Keyword.get(key, default)}
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_get_values/3` take a *derivable opts*, *key* and default and,
if the derived opts has the *key*, returns the values
(`Keyword.get_values/21`).
Otherwise the "listified" (`List.wrap/1`) default is returned.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_get_values(:a)
{:ok, [1]}
iex> [a: 11, b: 21, c: 31, a: 12, b: 22, c: 32, a: 13, b: 23, c: 33] |> opts_get_values(:c)
{:ok, [31, 32, 33]}
iex> [a: 1, b: 2, c: 3] |> opts_get_values(:d, 4)
{:ok, [4]}
iex> [a: 1, b: 2, c: 3] |> opts_get_values(:d, [41, 42, 43])
{:ok, [41, 42, 43]}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_get_values("a")
...> error |> Exception.message
"key invalid, got: a"
iex> {:error, error} = 42 |> opts_get_values(:a)
...> error |> Exception.message
"opts not derivable, got: 42"
"""
@since "0.1.0"
@spec opts_get_values(any, any, any) :: {:ok, list} | {:error, error}
def opts_get_values(opts, key, default \\ nil) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, key} <- key |> validate_key do
opts
|> Keyword.has_key?(key)
|> case do
true ->
{:ok, opts |> Keyword.get_values(key)}
_ ->
{:ok, default |> List.wrap()}
end
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_fetch/2` take a *derivable opts* and *key* and and returns
the *last* value for the key (or default) as `{:ok, value}`.
Note this is different to `Keyword.fetch/2` that returns the *first* value.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_fetch(:a)
{:ok, 1}
iex> [a: 11, b: 21, c: 31, a: 12, b: 22, c: 32, a: 13, b: 23, c: 33] |> opts_fetch(:c)
{:ok, 33}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_fetch(:d)
...> error |> Exception.message
"key :d not found in: [a: 1, b: 2, c: 3]"
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_fetch("a")
...> error |> Exception.message
"key invalid, got: a"
iex> {:error, error} = 42 |> opts_fetch(:a)
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_fetch(:a)
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_fetch(any, any) :: {:ok, any} | {:error, error}
def opts_fetch(opts, key) do
with {:ok, norm_opts} <- opts |> opts_normalise,
{:ok, key} <- key |> validate_key do
norm_opts
|> Enum.reverse()
|> Keyword.fetch(key)
|> case do
{:ok, _} = result ->
result
:error ->
new_key_error_result(key, opts)
end
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_put/3` take a *derivable opts*, *key* and a value and *appends* the `{key,value}` tuple returnsing `{:ok, opts}`.
Note this is different to `Keyword.put/2` which prepends the new `{key,value}` tuple and drops all the other for the same key.
## Examples
iex> [a: 11, b: 2, c: 3] |> opts_put(:a, 12)
{:ok, [a: 11, b: 2, c: 3, a: 12]}
iex> [a: 1, b: 2, c: 3] |> opts_put(:d, 4)
{:ok, [a: 1, b: 2, c: 3, d: 4]}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_put("a", 99)
...> error |> Exception.message
"key invalid, got: a"
iex> {:error, error} = 42 |> opts_put(:a, nil)
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_put(:a, nil)
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_put(any, any, any) :: {:ok, any} | {:error, error}
def opts_put(opts, key, value) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, key} <- key |> validate_key do
{:ok, opts ++ [{key, value}]}
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_put_new/3` take a *derivable opts*, *key* and a value.
If the *key* already exsists in the derived opts, they are returned unchanged as `{:ok, opts}`.
Otherwise `opts_put/3` is called to *append* the new `{key,value}`, again returning `{:ok, opts}`.
## Examples
iex> [a: 11, b: 2, c: 3] |> opts_put_new(:a, 12)
{:ok, [a: 11, b: 2, c: 3]}
iex> [a: 1, b: 2, c: 3] |> opts_put_new(:d, 4)
{:ok, [a: 1, b: 2, c: 3, d: 4]}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_put_new("a", 99)
...> error |> Exception.message
"key invalid, got: a"
iex> {:error, error} = 42 |> opts_put_new(:a)
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_put_new(:a)
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_put_new(any, any, any) :: {:ok, any} | {:error, error}
def opts_put_new(opts, key, value \\ nil) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, key} <- key |> validate_key do
opts
|> Keyword.has_key?(key)
|> case do
true ->
{:ok, opts}
_ ->
opts |> opts_put(key, value)
end
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_drop/3` take a *derivable opts*, *key* and delete *all* occurences of the *key* returning `{ok, opts}`.
It essentially wraps `Keyword.delete/2`.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_drop(:a)
{:ok, [b: 2, c: 3]}
iex> [a: 11, b: 21, c: 31, a: 12, b: 22, c: 32, a: 13, b: 23, c: 33] |> opts_drop([:a, :c])
{:ok, [b: 21, b: 22, b: 23]}
iex> {:error, error} = [a: 1, b: 2, c: 3] |> opts_drop([:b, "a"])
...> error |> Exception.message
"bad key \"a\" for: [:b, \"a\"]"
iex> {:error, error} = 42 |> opts_drop(:a)
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_drop(:a)
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_drop(any, any) :: {:ok, opts} | {:error, error}
def opts_drop(opts, keys) do
with {:ok, opts} <- opts |> opts_normalise,
{:ok, keys} <- keys |> normalise_key_list do
{:ok, opts |> Keyword.drop(keys)}
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_reduce/3` take a *derivable opts*, realises the derived opts, and calls `Keyword.new/1` to take the *last* `{key, value}` tuple for the same key, returning `{:ok, reduced_opts}`.
## Examples
iex> [a: 1, b: 2, c: 3] |> opts_reduce
{:ok, [a: 1, b: 2, c: 3]}
iex> {:ok, opts} = %{a: 1, b: 2, c: 3} |> opts_reduce
...> opts |> Enum.sort
[a: 1, b: 2, c: 3]
iex> [a: 11, b: 21, c: 31, a: 12, b: 22, c: 32, a: 13, b: 23, c: 33] |> opts_reduce
{:ok, [a: 13, b: 23, c: 33]}
iex> {:error, error} = 42 |> opts_reduce
...> error |> Exception.message
"opts not derivable, got: 42"
iex> {:error, error} = [{:a, 1}, {:b, 2}, {"c", 3}] |> opts_reduce
...> error |> Exception.message
"opts not derivable, got: [{:a, 1}, {:b, 2}, {\"c\", 3}]"
"""
@since "0.1.0"
@spec opts_reduce(any) :: {:ok, opts} | {:error, error}
def opts_reduce(opts \\ [])
def opts_reduce([]) do
{:ok, []}
end
def opts_reduce(opts) do
with {:ok, opts} <- opts |> opts_normalise do
{:ok, opts |> Keyword.new()}
else
{:error, %{__exception__: true}} = result -> result
end
end
@doc ~S"""
`opts_create_aliases_tuples/1` takes an *opts* where the keys are the canonical key names, and their values are zero (nil), one or more aliases for the canonical key.
A `Keyword` is returned where each key is an alias and its value the canonical key.
The canonical key also has an entry for itself with the same value.
## Examples
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opts_create_aliases_tuples
[a: :a, b: :b, b1: :b, c: :c, c1: :c, c2: :c, c3: :c]
"""
@since "0.1.0"
@spec opts_create_aliases_tuples(aliases_kvs) :: aliases_tuples
def opts_create_aliases_tuples(aliases) do
aliases
|> Enum.map(fn
{k, nil} ->
{k, k}
{k, a} ->
[k | a |> List.wrap()]
|> Enum.uniq()
|> Enum.map(fn a -> {a, k} end)
end)
|> List.flatten()
end
@doc ~S"""
`opts_create_aliases_dict/1` does the same job as `opts_create_aliases_tuples/1` but returns a *key alias dict*.
## Examples
iex> [a: nil, b: [:b1], c: [:c1, :c2, :c3]] |> opts_create_aliases_dict
%{a: :a, b: :b, b1: :b, c: :c, c1: :c, c2: :c, c3: :c}
"""
@since "0.1.0"
@spec opts_create_aliases_dict(aliases_kvs) :: aliases_dict
def opts_create_aliases_dict(aliases) do
aliases
|> opts_create_aliases_tuples
|> Enum.into(%{})
end
end
|
lib/fontais/option/option.ex
| 0.889996 | 0.641338 |
option.ex
|
starcoder
|
defmodule Blake2 do
import Bitwise
@moduledoc """
BLAKE2 hash functions
Implementing "Blake2b" and "Blake2s" as described in [RFC7693](https://tools.ietf.org/html/rfc7693)
Note that, at present, this only supports full message hashing and no OPTIONAL features
of BLAKE2.
"""
defp modulo(n, 64), do: n |> rem(18_446_744_073_709_551_616)
defp modulo(n, 32), do: n |> rem(4_294_967_296)
defp rotations(64), do: {32, 24, 16, 63}
defp rotations(32), do: {16, 12, 8, 7}
defp mix(v, i, [x, y], bc) do
[a, b, c, d] = extract_elements(v, i, [])
{r1, r2, r3, r4} = rotations(bc)
a = modulo(a + b + x, bc)
d = rotr(bxor(d, a), r1, bc)
c = modulo(c + d, bc)
b = rotr(bxor(b, c), r2, bc)
a = modulo(a + b + y, bc)
d = rotr(bxor(d, a), r3, bc)
c = modulo(c + d, bc)
b = rotr(bxor(b, c), r4, bc)
update_elements(v, [a, b, c, d], i)
end
defp rotr(x, n, b), do: modulo(bxor(x >>> n, x <<< (b - n)), b)
defp compress(h, m, t, f, b) do
v = (h ++ iv(b)) |> List.to_tuple()
rounds =
case b do
32 -> 10
_ -> 12
end
v
|> update_elements(
[
bxor(elem(v, 12), modulo(t, b)),
bxor(elem(v, 13), t >>> b),
if(f, do: bxor(elem(v, 14), mask(b)), else: elem(v, 14))
],
[12, 13, 14]
)
|> mix_rounds(m, rounds, rounds, b)
|> update_state(h)
end
defp mask(64), do: 0xFFFFFFFFFFFFFFFF
defp mask(32), do: 0xFFFFFFFF
defp update_state(v, h), do: update_state_list(v, h, 0, [])
defp update_state_list(_v, [], _i, acc), do: acc |> Enum.reverse()
defp update_state_list(v, [h | t], i, acc),
do: update_state_list(v, t, i + 1, [h |> bxor(elem(v, i)) |> bxor(elem(v, i + 8)) | acc])
defp mix_rounds(v, _m, 0, _c, _b), do: v
defp mix_rounds(v, m, n, c, b) do
s = sigma(c - n)
msg_word_pair = fn x -> [elem(m, elem(s, 2 * x)), elem(m, elem(s, 2 * x + 1))] end
v
|> mix([0, 4, 8, 12], msg_word_pair.(0), b)
|> mix([1, 5, 9, 13], msg_word_pair.(1), b)
|> mix([2, 6, 10, 14], msg_word_pair.(2), b)
|> mix([3, 7, 11, 15], msg_word_pair.(3), b)
|> mix([0, 5, 10, 15], msg_word_pair.(4), b)
|> mix([1, 6, 11, 12], msg_word_pair.(5), b)
|> mix([2, 7, 8, 13], msg_word_pair.(6), b)
|> mix([3, 4, 9, 14], msg_word_pair.(7), b)
|> mix_rounds(m, n - 1, c, b)
end
@doc """
Blake2b hashing
Note that the `output_size` is in bytes, not bits
- 64 => Blake2b-512 (default)
- 48 => Blake2b-384
- 32 => Blake2b-256
Per the specification, any `output_size` between 1 and 64 bytes is supported.
"""
@spec hash2b(binary, pos_integer, binary) :: binary | :error
def hash2b(m, output_size \\ 64, secret_key \\ ""), do: hash(m, 64, output_size, secret_key)
@doc """
Blake2s hashing
Note that the `output_size` is in bytes, not bits
- 32 => Blake2s-256 (default)
- 24 => Blake2b-192
- 16 => Blake2b-128
Per the specification, any `output_size` between 1 and 32 bytes is supported.
"""
@spec hash2s(binary, pos_integer, binary) :: binary | :error
def hash2s(m, output_size \\ 32, secret_key \\ ""), do: hash(m, 32, output_size, secret_key)
defp hash(m, b, output_size, secret_key)
when byte_size(secret_key) <= b and output_size <= b and output_size >= 1 do
ll = byte_size(m)
kk = byte_size(secret_key)
key =
case {ll, kk} do
{0, 0} -> <<0>>
_ -> secret_key
end
key
|> pad(b * 2)
|> (&(&1 <> m)).()
|> pad(b * 2)
|> block_msg(b)
|> msg_hash(ll, kk, output_size, b)
end
# Wrong-sized stuff
defp hash(_m, _secret_key, _b, _output_size), do: :error
defp pad(b, n) when b |> byte_size |> rem(n) == 0, do: b
defp pad(b, n), do: pad(b <> <<0>>, n)
defp block_msg(m, bs), do: break_blocks(m, {}, [], bs)
defp break_blocks(<<>>, {}, blocks, _bs), do: blocks |> Enum.reverse()
defp break_blocks(to_break, block_tuple, blocks, bs) do
<<i::unsigned-little-integer-size(bs), rest::binary>> = to_break
{block_tuple, blocks} =
case tuple_size(block_tuple) do
15 -> {{}, [Tuple.insert_at(block_tuple, 15, i) | blocks]}
n -> {Tuple.insert_at(block_tuple, n, i), blocks}
end
break_blocks(rest, block_tuple, blocks, bs)
end
defp msg_hash(blocks, ll, kk, nn, b) do
[h0 | hrest] = iv(b)
[h0 |> bxor(0x01010000) |> bxor(kk <<< 8) |> bxor(nn) | hrest]
|> process_blocks(blocks, kk, ll, 1, b)
|> list_to_binary(<<>>, b)
|> binary_part(0, nn)
end
defp list_to_binary([], bin, _b), do: bin
defp list_to_binary([h | t], bin, b),
do: list_to_binary(t, bin <> (h |> :binary.encode_unsigned(:little) |> pad(div(b, 8))), b)
defp process_blocks(h, [final_block], kk, ll, _n, b) when kk == 0,
do: compress(h, final_block, ll, true, b)
defp process_blocks(h, [final_block], kk, ll, _n, b) when kk != 0,
do: compress(h, final_block, ll + b * 2, true, b)
defp process_blocks(h, [d | rest], kk, ll, n, b),
do: process_blocks(compress(h, d, n * b * 2, false, b), rest, kk, ll, n + 1, b)
defp extract_elements(_v, [], a), do: a |> Enum.reverse()
defp extract_elements(v, [this | rest], a), do: extract_elements(v, rest, [elem(v, this) | a])
defp update_elements(v, [], []), do: v
defp update_elements(v, [n | m], [i | j]),
do: v |> Tuple.delete_at(i) |> Tuple.insert_at(i, n) |> update_elements(m, j)
# Initialization vector
defp iv(64),
do: [
0x6A09E667F3BCC908,
0xBB67AE8584CAA73B,
0x3C6EF372FE94F82B,
0xA54FF53A5F1D36F1,
0x510E527FADE682D1,
0x9B05688C2B3E6C1F,
0x1F83D9ABFB41BD6B,
0x5BE0CD19137E2179
]
defp iv(32),
do: [
0x6A09E667,
0xBB67AE85,
0x3C6EF372,
0xA54FF53A,
0x510E527F,
0x9B05688C,
0x1F83D9AB,
0x5BE0CD19
]
# Word schedule permutations
defp sigma(0), do: {00, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
defp sigma(1), do: {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}
defp sigma(2), do: {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}
defp sigma(3), do: {07, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8}
defp sigma(4), do: {09, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13}
defp sigma(5), do: {02, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9}
defp sigma(6), do: {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11}
defp sigma(7), do: {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10}
defp sigma(8), do: {06, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5}
defp sigma(9), do: {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0}
defp sigma(10), do: {00, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
defp sigma(11), do: {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}
end
|
lib/blake2.ex
| 0.746509 | 0.627666 |
blake2.ex
|
starcoder
|
defmodule Talan.Counter do
@moduledoc """
Linear probabilistic counter implementation with **concurrent accessibility**,
powered by [:atomics](http://erlang.org/doc/man/atomics.html) module for cardinality estimation.
Cardinality is the count of unique elements.
For more info about linear probabilistic counting:
[linear probabilistic counting](https://www.waitingforcode.com/big-data-algorithms/cardinality-estimation-linear-probabilistic-counting/read)
"""
@enforce_keys [:atomics_ref, :filter_length, :hash_function]
defstruct [:atomics_ref, :filter_length, :hash_function]
@type t :: %__MODULE__{
atomics_ref: reference,
filter_length: non_neg_integer,
hash_function: function
}
alias Talan.Counter
@doc """
Returns a new `%Talan.Counter{}` struct.
`expected_cardinality` is the max number of uniq items the counter will
handle with approx 1% of error rate.
## Options
* `hash_function` - defaults to `Murmur.hash_x64_128/1`
## Examples
iex> c = Talan.Counter.new(10_000)
iex> c |> Talan.Counter.put(["you", :can, Hash, {"any", "elixir", "term"}])
iex> c |> Talan.Counter.put("more")
iex> c |> Talan.Counter.put("another")
iex> c |> Talan.Counter.cardinality()
3
"""
@spec new(non_neg_integer, list) :: t
def new(expected_cardinality, options \\ []) do
hash_function = options |> Keyword.get(:hash_function, &Murmur.hash_x64_128/1)
# good defaults
required_size = max(1, round(Float.floor(expected_cardinality * 10 / 64)))
%Counter{
atomics_ref: :atomics.new(required_size, signed: false),
filter_length: required_size * 64,
hash_function: hash_function
}
end
@doc """
Hashes `term` and sets a bit to mark it has been seen.
Doesn't store the `term` so it's space efficient.
Uses `:atomics` so it's mutable & highly concurrent.
Returns `:ok`.
## Examples
iex> c = Talan.Counter.new(10_000)
iex> c |> Talan.Counter.put(["you", :can, Hash, {"any", "elixir", "term"}])
:ok
"""
@spec put(t, any) :: :ok
def put(%Counter{} = counter, term) do
hash = rem(counter.hash_function.(term), counter.filter_length)
Abit.set_bit_at(counter.atomics_ref, hash, 1)
:ok
end
@doc """
Returns the estimated cardinality for the given
`%Talan.Counter{}` struct.
## Examples
iex> c = Talan.Counter.new(10_000)
iex> c |> Talan.Counter.put(["you", :can, Hash, {"any", "elixir", "term"}])
iex> c |> Talan.Counter.put(["you", :can, Hash, {"any", "elixir", "term"}])
iex> c |> Talan.Counter.cardinality()
1
iex> c |> Talan.Counter.put("more")
iex> c |> Talan.Counter.cardinality()
2
"""
@spec cardinality(t) :: non_neg_integer
def cardinality(%Counter{atomics_ref: atomics_ref}) do
bit_count = Abit.bit_count(atomics_ref)
set_bit_count = Abit.set_bits_count(atomics_ref)
unset_bit_count = bit_count - set_bit_count
round(-bit_count * :math.log(unset_bit_count / bit_count))
end
end
|
lib/talan/counter.ex
| 0.927256 | 0.689619 |
counter.ex
|
starcoder
|
defmodule Grapex.Model.Logicenn do
import Grapex.TupleUtils
# alias Grapex.IOutils, as: IO_
require Axon
defp relation_embeddings(%Axon{output_shape: parent_shape} = x, n_relations, opts \\ []) do
n_hidden_units = last(parent_shape) - 1
output_shape = parent_shape
|> delete_last
|> Tuple.append(last(parent_shape) - 1)
|> Tuple.append(n_relations + 1) # there will be a coefficient for every relation + coefficient for the observer relation
kernel_shape = {n_hidden_units, n_relations}
kernel_initializer = opts[:kernel_initializer]
kernel_regularizer = opts[:kernel_regularizer]
kernel = Axon.param("kernel", kernel_shape, initializer: kernel_initializer, regularizer: kernel_regularizer)
Axon.layer(
x,
fn input, params ->
input_shape = Nx.shape(input)
n_hidden_units = (Nx.shape(input) |> elem(2)) - 1
observed_relation_indices = input
|> Nx.slice_axis(n_hidden_units, 1, 2) # take indices of the observed relations from the join input tensor
|> Nx.new_axis(-1, :relationship_dimension)
|> Nx.tile([1, 1, n_hidden_units, 1]) # align to the shape of input, last dimension has just one value since there is one observer relation per triple
tiled_input = input
|> Nx.slice_axis(0, n_hidden_units, 2) # discard the last vectors from the 2nd axis which contain indices of observed relations
|> Nx.new_axis(-1, :relationship_dimension)
|> Nx.tile(
(for _ <- 1..tuple_size(Nx.shape(input)), do: 1) ++ [n_relations]
)
batch_size = input_shape
|> delete_last
|> Tuple.to_list
result = params["kernel"]
|> Grapex.NxUtils.new_axes(batch_size)
|> Nx.multiply(tiled_input)
observed_relations = Nx.take_along_axis(result, Nx.as_type(observed_relation_indices, {:s, 64}), axis: 3)
Nx.concatenate([result, observed_relations], axis: 3)
end,
output_shape,
%{"kernel" => kernel},
"logicenn_scoring"
)
end
defp inner_product(%Axon{output_shape: parent_shape} = x, units, opts) do
activation = opts[:activation]
enable_bias = Keyword.get(opts, :enable_bias, true)
parent_shape_without_first_element = delete_first(parent_shape) # delete variable batch size
param_shape = parent_shape_without_first_element
|> delete_first # delete constant batch size
|> Tuple.append(units) # add number of units in layer
output_shape =
parent_shape
|> delete_last(2) # delete entity embedding size and number of entities per triple from the parent node output shape
|> Tuple.append(units)
kernel_initializer = opts[:kernel_initializer]
kernel_regularizer = opts[:kernel_regularizer]
bias_initializer = unless enable_bias, do: nil, else: opts[:bias_initializer]
bias_regularizer = unless enable_bias, do: nil, else: opts[:bias_regularizer]
kernel = Axon.param("kernel", param_shape, initializer: kernel_initializer, regularizer: kernel_regularizer)
bias = unless enable_bias, do: nil, else: Axon.param("bias", param_shape, initializer: bias_initializer, regularizer: bias_regularizer)
node = Axon.layer(
x,
fn input, params ->
bias = unless enable_bias, do: nil, else: params["bias"]
kernel = params["kernel"]
kernel_shape = Nx.shape(kernel)
# align input to number of units in the hidden layer
tiled_input =
input
|> Nx.new_axis(-1)
|> Nx.tile(
(for _ <- 1..tuple_size(Nx.shape(input)), do: 1) ++ [last(kernel_shape)]
)
# align bias to batch size
tiled_bias = unless enable_bias, do: nil, else: Grapex.NxUtils.new_axes(
bias,
elems(
Nx.shape(input),
[
0, # variable batch size
1 # constant batch size
]
)
)
# align kernel to batch size
tiled_kernel = Grapex.NxUtils.new_axes(
kernel,
elems(
Nx.shape(input),
[
0, # n elements per triple ( = 2 )
1 # constant batch size
]
)
)
tiled_input
|> Nx.multiply(tiled_kernel)
|> (
fn(x) ->
unless enable_bias do
x
else
x
|> Nx.add(tiled_bias)
end
end
).()
# |> Nx.add(tiled_bias)
# |> Nx.max(0) # relu
# |> Nx.multiply(tiled_bias)
|> Nx.sum(axes: [-2, -3]) # eliminate dimensions which correspond to the entity embedding size and number of entities per triple
end,
output_shape,
(unless enable_bias, do: %{"kernel" => kernel}, else: %{"kernel" => kernel, "bias" => bias}),
"logicenn_inner_product"
)
if activation do
Axon.activation(node, activation)
else
node
end
end
def model(%Grapex.Init{entity_dimension: entity_embedding_size, input_size: batch_size, hidden_size: hidden_size, enable_bias: enable_bias}) do
product = Axon.input({nil, batch_size, 2})
|> Axon.embedding(Grapex.Meager.n_entities, entity_embedding_size)
# |> Axon.layer_norm
|> inner_product(hidden_size, activation: :relu, enable_bias: enable_bias)
score = product
|> Axon.concatenate(
Axon.input({nil, batch_size, 1}),
axis: 2
)
|> relation_embeddings(Grapex.Meager.n_relations)
Axon.concatenate(
product
|> Axon.reshape({1, batch_size, hidden_size, 1})
|> Axon.pad([{0, 0}, {0, 0}, {0, Grapex.Meager.n_relations}]),
score
|> Axon.reshape({1, batch_size, hidden_size, Grapex.Meager.n_relations + 1}),
axis: 1
) # |> IO.inspect
# Resulting dimensions:
# - variable batch size
# - generated value kinds ( = 2, the first contains values of f_ht functions which are independent of relations and the other one contains the same values multiplied by relations)
# - constant batch size
# - hidden size (number of units per hidden layer)
# - relations + 1 (one is reserved for tracking the observed relation)
end
defp fix_shape(x, first_dimension) do
case {x, first_dimension} do
{%{shape: {_, _, _, _}}, 1} ->
Nx.new_axis(x, 0)
{%{shape: {_, _, _, _}}, _} ->
Nx.new_axis(x, 0)
|> Nx.tile([first_dimension, 1, 1, 1, 1])
_ -> x
end
end
def compute_score(x) do
x
# |> Grapex.IOutils.inspect_shape("original x")
|> Nx.slice_axis(1, 1, 1) # Drop intermediate results of inner products calculation
# |> Nx.slice_axis(0, 1, 1) # Drop intermediate results of inner products calculation
# |> Nx.slice_axis(elem(Nx.shape(x), tuple_size(Nx.shape(x)) - 1) - 1, 1, -1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
|> Nx.slice_axis(last(Nx.shape(x)) - 1, 1, -1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
# |> Nx.slice_axis(last(Nx.shape(x)) - 1, 1, tuple_size(Nx.shape(x)) - 1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
# |> Nx.slice_axis(0, 1, tuple_size(Nx.shape(x)) - 1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
|> Nx.slice_axis(0, 1, -1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
# |> Grapex.IOutils.inspect_shape("reshaped x")
|> Nx.squeeze(axes: [1, -1])
|> Nx.sum(axes: [-1]) # Sum up values corresponding to different values of L for the same (observed) relation
end
def compute_loss_component(x, opts \\ []) do
multiplier = Keyword.get(opts, :multiplier)
x
|> compute_score
|> Nx.multiply(if multiplier == nil, do: 1, else: multiplier)
|> Nx.multiply(-1)
|> Nx.exp
|> Nx.add(1)
|> Nx.log
end
def take_triples(x, index, inserted_dimension \\ 2) do
fixed_x =
fix_shape(x, inserted_dimension)
Nx.reshape(
fixed_x,
Nx.shape(fixed_x)
|> delete_first
|> Tuple.insert_at(0, 2)
|> Tuple.insert_at(0, :auto)
)
|> (
fn(y) ->
if index >= 0 do
Nx.slice_axis(y, index, 1, 0) # last dimension corresponds to the observed triples
else
Nx.slice_axis(y, (Nx.shape(y) |> elem(0)) + index, 1, 0)
end
end
).()
|> Nx.squeeze(axes: [0])
end
def compute_loss(x, opts \\ []) do # when pattern == :symmetric do
pattern = Keyword.get(opts, :pattern, nil)
lambda = Keyword.get(opts, :lambda, nil)
# enable_regularization = Keyword.get(opts, :enable_regularization, true)
# fixed_x =
# fix_shape(x, 2)
#
# fixed_x =
# Nx.reshape(
# fixed_x,
# Nx.shape(fixed_x)
# |> delete_first
# |> Tuple.insert_at(0, 2)
# |> Tuple.insert_at(0, :auto)
# )
# |> Nx.slice_axis(-1, 1, 0) # last dimension corresponds to the observed triples
# |> Nx.squeeze(axes: [0])
fixed_x =
x
|> take_triples(-1)
Nx.concatenate(
[
Nx.slice_axis(fixed_x, 0, 1, 0) # positive_triples
|> compute_loss_component
|> (
fn(positive_loss_component) ->
unless lambda == nil do
compute_regularization(x, pattern, opts)
|> Nx.multiply(lambda)
|> Nx.add(positive_loss_component)
else
positive_loss_component
end
end
).(),
# |> IO_.inspect_shape("Positive triples shape")
Nx.slice_axis(fixed_x, 1, 1, 0) # negative triples
|> compute_loss_component(multiplier: -1)
# |> IO_.inspect_shape("Negative triples shape")
]
)
|> Nx.flatten
end
def compute_regularization(x, pattern, opts \\ []) do
case pattern do
binary_pattern when binary_pattern == :symmetric or binary_pattern == :inverse ->
margin = Keyword.get(opts, :margin, 0)
x
|> take_triples(0, 4) # forward triples
|> Nx.slice_axis(0, 1, 0) # positive_triples
|> Nx.slice_axis(1, 1, 1) # Drop intermediate results of inner products calculation
|> Nx.slice_axis(last(Nx.shape(x)) - 1, 1, -1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
|> Nx.squeeze(axes: [1, -1])
|> Nx.subtract(
x
|> take_triples(1, 4) # backward triples
|> Nx.slice_axis(0, 1, 0) # positive_triples
|> Nx.slice_axis(1, 1, 1) # Drop intermediate results of inner products calculation
|> Nx.slice_axis(last(Nx.shape(x)) - 1, 1, -1) # Drop padding values in the last dimension which represents number of relations, last values correspond to the observed relations
|> Nx.squeeze(axes: [1, -1])
)
|> Nx.abs
|> Nx.subtract(margin)
|> Nx.max(0)
|> Nx.sum(axes: [-1]) # Sum up values corresponding to different values of L for the same (observed) relation
|> Nx.flatten
# |> IO_.inspect_shape("Shape of symmetric regularization")
_ ->
IO.puts "No regularization-specific loss components are defined for pattern #{pattern}"
0
end
end
end
|
lib/grapex/models/logicenn.ex
| 0.75274 | 0.589126 |
logicenn.ex
|
starcoder
|
defmodule Affine do
@moduledoc """
This library performs affine transforms for multiple dimensions. The
implementation is simple in this initial version allowing for translation,
scaling, shear and rotation.
This library uses the Matrix library available on Hex. It is automatically included when using this library as a dep in your application.
## Using The Affine Library
The capabilities of the library can be accessed through either a low level api or a higher level one.
### Low Level API
The transform library can be accessed at it's lowest level giving the best
performance and full control to the developer. An example of using the API at
this level is:
t_translate = Affine.Transforms.translate (3.0, 4.0, 5.0)
point = Affine.transform t_translate [ 1.0, 2.0, 3.0 ]
assert point == [4.0, 6.0, 8.0]
And to add a transform to the first one:
t_scale = Affine.Transforms.scale (2.0, 2.0, 2.0)
t_scale_then_translate = Affine.multiply t_translate, t_scale
point = Affine.transform t_scale_then_translate [ 1.0, 2.0, 3.0 ]
assert point == [ 5.0, 8.0, 11.0 ]
Keep in mind that the order individual transforms are provided to the multiply
function is important since transforms are not commutative. With the same
example as above but with t_translate and t_scale reversed, the resulting point is different:
t_translate_then_scale = Affine.multiply t_scale, t_translate
point = Affine.transform t_translate_then_scale [ 1.0, 2.0, 3.0 ]
assert point == [ 8.0, 12.0, 16.0 ]
The last transform, t_translate, in this case will be the first to be done. Of course,
the beauty of Affine transforms is that all multiplied transforms are done
simultaneously but logically, the last transform multiplied is the first to be
applied.
### High Level API
The easier API for creating and using Affine transforms uses the flexibility
provided in Elixir to more elegantly define the transforms. This requires a bit more processing but generally would not be a burden to the application unless
many transforms are being created. Here's an example:
t_translate = Affine.create [ type: :translate, dimensions: 3, x: 3.0, y: 4.0, z: 5.0]
point = Affine.transform t_translate [ 1.0, 2.0, 3.0]
assert point == [4.0, 6.0, 8.0]
So the create function takes a parameter list and generates the correct
transform. The create function can also take a list of parameter lists and
generate a single transform from those parameter lists. For example, to create,
t_translate_then_scale with a single call to create, the following can be done:
point =
[ [type: :translate, dimensions: 3, x: 3.0, y: 4.0, z: 5.0],
[type: :scale, dimensions: 3, x: 2.0, y: 2.0, z: 2.0] ]
|> Affine.create
|> Affine.transform [1.0, 2.0, 3.0]
assert point == [ 8.0, 12.0, 16.0 ]
Note the order of transforms in the parameter list is applied such that the first transform in the parameter list is the last one applied to the final transform. Logically, it is the first one to be applied when using the final transform.
Of course, the above is only useful for a one time point transformation since
the generate transform is not saved. So the following is likely to be more
useful:
t_translate_then_scale =
[ [type: :translate, dimensions: 3, x: 3.0, y: 4.0, z: 5.0],
[type: :scale, dimensions: 3, x: 2.0, y: 2.0, z: 2.0] ]
|> Affine.create
point = t_translate_then_scale
|> Affine.transform [1.0, 2.0, 3.0]
assert point == [ 8.0, 12.0, 16.0 ]
### Linear Maps
Generating 2D graphics, either for charting, design or other reasons, can require reassignment of a space on the drawing canvas for a part of the graphic.
For instance, creating the x-axis in a chart that goes for 0-21 for the data in the area from pixel 143 to pixel 200 on the drawing canvas can use a transform to easily convert from data space to canvas space.
A special type of 'create' parameter list can be used to generate the transform for the very example just stated. Here's how it looks:
t =
[type: :linear_map, x1_in: 0.0, x1_out: 143.0, x2_in: 21.0, x2_out: 200.0]
|> Affine.create
This code generates a 1D transform with translation and scaling such that a value of 0 in will generate 143 and a value of 21 in will generate a 200.
point = Affine.map (t, 0.0)
assert point == 143
point = Affine.map (t, 21.0)
assert point == 200
"""
@type matrix :: [[number]]
@type point :: [number]
@type list_of_specs :: [[]]
@spec create(list_of_specs) :: matrix
defdelegate create(parameters), to: Affine.Generator, as: :create
@spec m(matrix,matrix) :: matrix
defdelegate m(matrix1,matrix2), to: Affine.Operations, as: :multiply
@spec multiply(matrix,matrix) :: matrix
defdelegate multiply(matrix1,matrix2), to: Affine.Operations, as: :multiply
@spec t(matrix,point) :: point
defdelegate t(matrix,point), to: Affine.Operations, as: :transform
@spec transform(matrix,point) :: point
defdelegate transform(matrix,point), to: Affine.Operations, as: :transform
@spec map(matrix,number) :: number
defdelegate map(matrix,value), to: Affine.LinearMap, as: :map
end
|
lib/affine.ex
| 0.942109 | 0.898633 |
affine.ex
|
starcoder
|
defmodule Advent.Y2021.D10 do
@moduledoc """
https://adventofcode.com/2021/day/10
"""
@doc """
Find the first illegal character in each corrupted line of the navigation
subsystem. What is the total syntax error score for those errors?
"""
@spec part_one(Enumerable.t()) :: non_neg_integer()
def part_one(input) do
input
|> parse_input()
|> Stream.map(fn
{:corrupted, score} -> score
_ -> 0
end)
|> Enum.sum()
end
@doc """
Find the completion string for each incomplete line, score the completion
strings, and sort the scores. What is the middle score?
"""
@spec part_two(Enumerable.t()) :: non_neg_integer()
def part_two(input) do
input
|> parse_input()
|> Enum.reduce([], fn
{:incomplete, score}, acc -> [score | acc]
_, acc -> acc
end)
|> Enum.sort()
# Get middle value - assumed to be odd length (median)
|> (&Enum.at(&1, div(length(&1), 2))).()
end
@spec parse_input(Enumerable.t()) :: Enumerable.t()
defp parse_input(input) do
input
|> Stream.map(&String.graphemes/1)
|> Stream.map(&parse_chunks/1)
end
@spec parse_chunks([String.grapheme()]) ::
:legal | {:corrupted, non_neg_integer()} | {:incomplete, non_neg_integer()}
defp parse_chunks(chunks) do
Enum.reduce_while(chunks, [], fn
")", ["(" | tail] -> {:cont, tail}
"]", ["[" | tail] -> {:cont, tail}
"}", ["{" | tail] -> {:cont, tail}
">", ["<" | tail] -> {:cont, tail}
")", _stack -> {:halt, 3}
"]", _stack -> {:halt, 57}
"}", _stack -> {:halt, 1197}
">", _stack -> {:halt, 25_137}
open, stack -> {:cont, [open | stack]}
end)
|> case do
[] -> :legal
res when is_list(res) -> {:incomplete, score_incomplete(res)}
res when is_integer(res) -> {:corrupted, res}
end
end
@spec score_incomplete([String.grapheme()]) :: non_neg_integer()
defp score_incomplete(incomplete) do
Enum.reduce(incomplete, 0, fn chunk, acc ->
acc * 5 +
case chunk do
"(" -> 1
"[" -> 2
"{" -> 3
"<" -> 4
end
end)
end
end
|
lib/advent/y2021/d10.ex
| 0.755457 | 0.565959 |
d10.ex
|
starcoder
|
defmodule Dune.Parser do
@moduledoc false
alias Dune.{AtomMapping, Success, Failure, Opts}
alias Dune.Parser.{CompileEnv, StringParser, Sanitizer, SafeAst, UnsafeAst}
@typep previous_session :: %{
atom_mapping: AtomMapping.t(),
compile_env: Dune.Parser.CompileEnv.t()
}
@spec parse_string(String.t(), Opts.t(), previous_session | nil) :: SafeAst.t() | Failure.t()
def parse_string(string, opts = %Opts{}, previous_session \\ nil) when is_binary(string) do
compile_env = get_compile_env(opts, previous_session)
string
|> do_parse_string(opts, previous_session)
|> Sanitizer.sanitize(compile_env)
end
defp do_parse_string(string, opts = %{max_length: max_length}, previous_session) do
case String.length(string) do
length when length > max_length ->
%Failure{type: :parsing, message: "max code length exceeded: #{length} > #{max_length}"}
_ ->
StringParser.parse_string(string, opts, previous_session)
end
end
@spec parse_quoted(Macro.t(), Opts.t(), previous_session | nil) :: SafeAst.t()
def parse_quoted(quoted, opts = %Opts{}, previous_session \\ nil) do
compile_env = get_compile_env(opts, previous_session)
quoted
|> unsafe_quoted()
|> Sanitizer.sanitize(compile_env)
end
def unsafe_quoted(ast) do
%UnsafeAst{ast: ast, atom_mapping: AtomMapping.new()}
end
defp get_compile_env(opts, nil) do
CompileEnv.new(opts.allowlist)
end
defp get_compile_env(opts, %{compile_env: compile_env}) do
%{compile_env | allowlist: opts.allowlist}
end
@spec string_to_quoted(String.t(), Opts.t()) :: Success.t() | Failure.t()
def string_to_quoted(string, opts) do
with unsafe = %UnsafeAst{} <- StringParser.parse_string(string, opts, nil, false) do
inspected = inspect(unsafe.ast, pretty: opts.pretty)
inspected = AtomMapping.replace_in_string(unsafe.atom_mapping, inspected)
%Success{
value: unsafe.ast,
inspected: inspected,
stdio: ""
}
end
end
end
|
lib/dune/parser.ex
| 0.741861 | 0.421641 |
parser.ex
|
starcoder
|
defmodule LineBot.Message.Imagemap do
use LineBot.Message
@moduledoc """
Represents an [Imagemap message](https://developers.line.biz/en/reference/messaging-api/#imagemap-message).
"""
@type t :: %__MODULE__{
baseUrl: String.t(),
altText: String.t(),
baseSize: %{width: integer(), height: integer()},
video: LineBot.Message.Imagemap.Video.t() | nil,
actions: [
LineBot.Message.Imagemap.Action.Message.t() | LineBot.Message.Imagemap.Action.URI.t()
],
type: :imagemap,
quickReply: LineBot.Message.QuickReply.t() | nil
}
@enforce_keys [:baseUrl, :altText, :baseSize, :actions]
defstruct [:baseUrl, :altText, :baseSize, :video, :actions, :quickReply, type: :imagemap]
end
defmodule LineBot.Message.Imagemap.Video do
use LineBot.Message
@moduledoc """
Represents the video component of a `t:LineBot.Message.Imagemap.t/0`.
"""
@type t :: %__MODULE__{
originalContentUrl: String.t(),
previewImageUrl: String.t(),
area: %{x: integer(), y: integer(), width: integer(), height: integer()},
externalLink: %{linkUri: String.t(), label: String.t()} | nil
}
@enforce_keys [:originalContentUrl, :previewImageUrl, :area]
defstruct [:originalContentUrl, :previewImageUrl, :area, :externalLink]
end
defmodule LineBot.Message.Imagemap.Action.Message do
use LineBot.Message
@moduledoc """
Represents an [Imagemap Message action object](https://developers.line.biz/en/reference/messaging-api/#imagemap-message-action-object).
"""
@type t :: %__MODULE__{
label: String.t() | nil,
text: String.t(),
area: %{x: integer(), y: integer(), width: integer(), height: integer()},
type: :message
}
@enforce_keys [:text, :area]
defstruct [:label, :text, :area, type: :message]
end
defmodule LineBot.Message.Imagemap.Action.URI do
use LineBot.Message
@moduledoc """
Represents an [Imagemap URI action object](https://developers.line.biz/en/reference/messaging-api/#imagemap-uri-action-object).
"""
@type t :: %__MODULE__{
label: String.t() | nil,
linkUri: String.t(),
area: %{x: integer(), y: integer(), width: integer(), height: integer()},
type: :uri
}
@enforce_keys [:linkUri, :area]
defstruct [:label, :linkUri, :area, type: :uri]
end
|
lib/line_bot/message/image_map.ex
| 0.880733 | 0.430656 |
image_map.ex
|
starcoder
|
defmodule Day22 do
def part1(input, moves \\ 10000) do
grid = parse(input)
|> Map.new
state = {{0, 0}, 0, 0, grid}
res = Stream.iterate(state, &next_state_part1/1)
|> Stream.drop(moves)
|> Enum.take(1)
|> hd
{_, _, infections, _} = res
infections
end
def part2(input, moves \\ 10000000) do
grid = parse(input)
|> Map.new
state = {{0, 0}, 0, 0, grid}
res = Stream.iterate(state, &next_state_part2/1)
|> Stream.drop(moves)
|> Enum.take(1)
|> hd
{_, _, infections, _} = res
infections
end
defp next_state_part1({location, direction, infections, grid}) do
case Map.get(grid, location, :clean) do
:infected ->
direction = turn_right(direction)
grid = Map.put(grid, location, :clean)
location = move(location, direction)
{location, direction, infections, grid}
:clean ->
direction = turn_left(direction)
grid = Map.put(grid, location, :infected)
infections = infections + 1
location = move(location, direction)
{location, direction, infections, grid}
end
end
defp next_state_part2({location, direction, infections, grid}) do
case Map.get(grid, location, :clean) do
:infected ->
direction = turn_right(direction)
grid = Map.put(grid, location, :flagged)
location = move(location, direction)
{location, direction, infections, grid}
:clean ->
direction = turn_left(direction)
grid = Map.put(grid, location, :weakened)
location = move(location, direction)
{location, direction, infections, grid}
:flagged ->
direction = direction |> turn_left |> turn_left
grid = Map.put(grid, location, :clean)
location = move(location, direction)
{location, direction, infections, grid}
:weakened ->
grid = Map.put(grid, location, :infected)
infections = infections + 1
location = move(location, direction)
{location, direction, infections, grid}
end
end
defp turn_left(direction) do
rem(4 + direction - 1, 4)
end
defp turn_right(direction) do
rem(4 + direction + 1, 4)
end
defp move({x, y}, direction) do
case direction do
0 -> {x, y - 1}
2 -> {x, y + 1}
1 -> {x + 1, y}
3 -> {x - 1, y}
end
end
defp parse(input) do
middle = div(length(input), 2)
input
|> Enum.with_index(-middle)
|> Enum.flat_map(fn {line, y} ->
String.to_charlist(line)
|> Enum.with_index(-middle)
|> Enum.map(fn {char, x} ->
location = {x, y}
state = case char do
?\# -> :infected
?\. -> :clean
end
{location, state}
end)
end)
end
end
|
day22/lib/day22.ex
| 0.654343 | 0.622832 |
day22.ex
|
starcoder
|
defmodule MetarMap do
@moduledoc """
MetarMap keeps the contexts that define your domain
and business logic.
Contexts are also responsible for managing your data, regardless
if it comes from the database, an external API or others.
"""
alias MetarMap.Display.Color
@doc """
Naively blends two colors
"""
def blend(from_color, to_color, to_factor) do
from_factor = 1.0 - to_factor
%Color{
r: trunc(from_color.r * from_factor + to_color.r * to_factor),
g: trunc(from_color.g * from_factor + to_color.g * to_factor),
b: trunc(from_color.b * from_factor + to_color.b * to_factor),
w: trunc(from_color.w * from_factor + to_color.w * to_factor)
}
end
@doc """
Naively blends two colors
"""
def blend(from_color, to_color, %Range{} = range, value) do
blend(from_color, to_color, {range.first, range.last}, value)
end
def blend(from_color, to_color, {first, last}, value) do
blend(from_color, to_color, normalize(first, last, value))
end
@spec blend_gradient([{number(), %Color{}}], number, term) :: %Color{} | term
def blend_gradient(_, nil, default), do: default
def blend_gradient(gradient, value, _default) when is_list(gradient) do
gradient = Enum.sort(gradient)
{first_value, first_color} = hd(gradient)
{last_value, last_color} = List.last(gradient)
cond do
value <= first_value ->
first_color
value >= last_value ->
last_color
true ->
pairs = Enum.zip(Enum.slice(gradient, 0..-2), Enum.slice(gradient, 1..-1))
Enum.reduce_while(pairs, nil, fn
{{min_value, _}, _}, _ when min_value > value ->
{:cont, nil}
{{min_value, min_color}, {max_value, max_color}}, _ ->
{:halt, blend(min_color, max_color, {min_value, max_value}, value)}
end)
end
end
@doc """
Changes a color's brightness.
"""
def brighten(color, rate) do
%Color{
r: (color.r * rate) |> min(255) |> max(0) |> trunc(),
g: (color.g * rate) |> min(255) |> max(0) |> trunc(),
b: (color.b * rate) |> min(255) |> max(0) |> trunc(),
w: (color.w * rate) |> min(255) |> max(0) |> trunc()
}
end
@doc """
Normalize a value from 0.0 to 1.0.
"""
def normalize(min, max, value) do
(value - min) / (max - min)
end
end
|
lib/metar_map.ex
| 0.858704 | 0.555194 |
metar_map.ex
|
starcoder
|
defmodule Bolt.Sips.Internals.PackStream.EncoderV1 do
@moduledoc false
alias Bolt.Sips.Internals.PackStream.EncoderHelper
use Bolt.Sips.Internals.PackStream.Markers
@doc """
Encode an atom into Bolt binary format.
Encoding:
`Marker`
with
| Value | Marker |
| ------- | -------- |
| nil | `0xC0` |
| false | `0xC2` |
| true | `0xC3` |
Other atoms are converted to string before encoding.
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_atom(nil, 1))
<<0xC0>>
iex> :erlang.iolist_to_binary(EncoderV1.encode_atom(true, 1))
<<0xC3>>
iex> :erlang.iolist_to_binary(EncoderV1.encode_atom(:guten_tag, 1))
<<0x89, 0x67, 0x75, 0x74, 0x65, 0x6E, 0x5F, 0x74, 0x61, 0x67>>
"""
@spec encode_atom(atom(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_atom(atom , bolt_version), do: EncoderHelper.call_encode(:atom, atom, bolt_version)
@doc """
Encode a string into Bolt binary format.
Encoding:
`Marker` `Size` `Content`
with
| Marker | Size | Max data size |
|--------|------|---------------|
| `0x80`..`0x8F` | None (contained in marker) | 15 bytes |
| `0xD0` | 8-bit integer | 255 bytes |
| `0xD1` | 16-bit integer | 65_535 bytes |
| `0xD2` | 32-bit integer | 4_294_967_295 bytes |
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_string("guten tag", 1))
<<0x89, 0x67, 0x75, 0x74, 0x65, 0x6E, 0x20, 0x74, 0x61, 0x67>>
"""
@spec encode_string(String.t(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_string(string, bolt_version), do: EncoderHelper.call_encode(:string, string, bolt_version)
@doc """
Encode an integer into Bolt binary format.
Encoding:
`Marker` `Value`
with
| | Marker |
|---|--------|
| tiny int | `0x2A` |
| int8 | `0xC8` |
| int16 | `0xC9` |
| int32 | `0xCA` |
| int64 | `0xCB` |
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_integer(74, 1))
<<0x4A>>
iex> :erlang.iolist_to_binary(EncoderV1.encode_integer(-74_789, 1))
<<0xCA, 0xFF, 0xFE, 0xDB, 0xDB>>
"""
@spec encode_integer(integer(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_integer(integer, bolt_version), do: EncoderHelper.call_encode(:integer, integer, bolt_version)
@doc """
Encode a float into Bolt binary format.
Encoding: `Marker` `8 byte Content`.
Marker: `0xC1`
Formated according to the IEEE 754 floating-point "double format" bit layout.
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_float(42.42, 1))
<<0xC1, 0x40, 0x45, 0x35, 0xC2, 0x8F, 0x5C, 0x28, 0xF6>>
"""
@spec encode_float(float(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_float(number, bolt_version), do: EncoderHelper.call_encode(:float, number, bolt_version)
@doc """
Encode a list into Bolt binary format.
Encoding:
`Marker` `Size` `Content`
with
| Marker | Size | Max list size |
|--------|------|---------------|
| `0x90`..`0x9F` | None (contained in marker) | 15 bytes |
| `0xD4` | 8-bit integer | 255 items |
| `0xD5` | 16-bit integer | 65_535 items |
| `0xD6` | 32-bit integer | 4_294_967_295 items |
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_list(["hello", "world"], 1))
<<0x92, 0x85, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x85, 0x77, 0x6F, 0x72, 0x6C, 0x64>>
"""
@spec encode_list(list(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_list(list, bolt_version), do: EncoderHelper.call_encode(:list, list, bolt_version)
@doc """
Encode a map into Bolt binary format.
Note that Elixir structs are converted to map for encoding purpose.
Encoding:
`Marker` `Size` `Content`
with
| Marker | Size | Max map size |
|--------|------|---------------|
| `0xA0`..`0xAF` | None (contained in marker) | 15 entries |
| `0xD8` | 8-bit integer | 255 entries |
| `0xD9` | 16-bit integer | 65_535 entries |
| `0xDA` | 32-bit integer | 4_294_967_295 entries |
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_map(%{id: 345, value: "hello world"}, 1))
<<0xA2, 0x82, 0x69, 0x64, 0xC9, 0x1, 0x59, 0x85, 0x76, 0x61, 0x6C, 0x75,
0x65, 0x8B, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64>>
"""
@spec encode_map(map(), integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_map(map, bolt_version), do: EncoderHelper.call_encode(:map, map, bolt_version)
@doc """
Encode a struct into Bolt binary format.
This concerns Bolt Structs as defined in []().
Elixir structs are just converted to regular maps before encoding
Encoding:
`Marker` `Size` `Signature` `Content`
with
| Marker | Size | Max structure size |
|--------|------|---------------|
| `0xB0`..`0xBF` | None (contained in marker) | 15 fields |
| `0xDC` | 8-bit integer | 255 fields |
| `0xDD` | 16-bit integer | 65_535 fields |
## Example
iex> alias Bolt.Sips.Internals.PackStream.EncoderV1
iex> :erlang.iolist_to_binary(EncoderV1.encode_struct({0x01, ["two", "params"]}, 1))
<<0xB2, 0x1, 0x83, 0x74, 0x77, 0x6F, 0x86, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x73>>
"""
@spec encode_struct({integer(), list()}, integer()) :: Bolt.Sips.Internals.PackStream.value()
def encode_struct(struct, bolt_version) , do: EncoderHelper.call_encode(:struct, struct, bolt_version)
end
|
lib/bolt_sips/internals/pack_stream/encoder_v1.ex
| 0.847936 | 0.659193 |
encoder_v1.ex
|
starcoder
|
defmodule EtsQuery do
@moduledoc """
EtsQuery gives you convinient function to work with ets tables
"""
alias :ets, as: Ets
import Ets
@doc """
looks up every row in the given ets table.
Type indicates whether the traversal should start from the start or the last row of the table.
It would matter if the table is :ordered_set
"""
def traversal(tab, func, type) do
traversal(tab, first_key(tab, type), func, type)
end
@doc """
looks up every row in the given ets table.
Type indicates whether the traversal should start from the start or the last row of the table.
It would matter if the table is :ordered_set
"""
@spec traversal(
atom | :ets.tid(),
any | :'$end_of_table',
fun,
:first | :last
) :: :'$end_of_table'
def traversal(_tab, :'$end_of_table', _func, _type), do: :'$end_of_table'
def traversal(tab, key, func, type) do
[outcome] = lookup(tab, key)
func.(outcome)
traversal(tab,
next_key(tab, type, key),
func,
type
)
end
defp next_key(tab, type, key) do
case type do
:first -> :ets.next(tab, key)
:last -> :ets.prev(tab, key)
end
end
defp first_key(tab, type) do
case type do
:first -> :ets.first(tab)
:last -> :ets.last(tab)
end
end
@doc """
new_row is a function for appending an element on a ets table where the row is expected to have a list
args: 1 => ets ref or atom, 2 => key for ets, value => an element you want to append
"""
@spec new_row(atom | :ets.tid(), any, any) :: true
def new_row(tab, key, value) do
append(tab, key, value)
end
@spec new_row(atom | :ets.tid(), {any, any}) :: true
def new_row(tab, tuple) do
append(tab, tuple)
end
defp value2list(value) when not is_list(value), do: [value]
defp value2list(value), do: value
@doc """
alias for new_row
"""
@spec append(atom | :ets.tid(), any, any) :: true
def append(tab, key, value) do
append(tab, {key, value})
end
@spec append(atom | :ets.tid(), {any, any}) :: true
def append(tab, {key, value}) do
new_value =
case lookup(tab, key) do
[] -> value2list(value)
[{_, existing_value}] ->
[value | existing_value]
end
insert(tab, {key, new_value})
end
@doc """
The row is expected to have a list as a value.
this function will removes an element from that list
"""
@spec remove_element(atom | :ets.tid(), any, (any -> boolean)) :: true
def remove_element(tab, key, match_func) do
[{_, value}] = lookup(tab, key)
filtered = filter_element(value, match_func)
len = length(value)
case length(filtered) do
^len -> :unremoved
_ -> insert(tab, {key, filtered})
end
end
defp filter_element(to_check, func, filtered \\ [])
defp filter_element([h | t], func, filtered) do
filtered =
case func.(h) do
true -> [h | filtered]
_ -> filtered
end
filter_element(t, func, filtered)
end
defp filter_element(_to_check, _func, filtered) do
filtered
end
@spec remove(atom | :ets.tid(), any, (any -> boolean)) :: true
def remove(tab, key, match_func) do
remove_element(tab, key, match_func)
end
@spec fetch(any, :map | :list) :: any
def fetch(tab, merge_type \\ :map) do
{:ok, pid} = Agent.start_link(fn -> %{} end)
try do
traversal(tab, fn {key, list} ->
Agent.update(pid, &
case merge_type do
:map ->
Map.merge(&1, %{ key => list })
:list ->
list ++ &1
end
)
end, :first)
data = Agent.get(pid, & &1)
Agent.stop(pid)
data
rescue _ ->
Agent.stop(pid)
end
end
end
|
lib/ets_query.ex
| 0.657758 | 0.706861 |
ets_query.ex
|
starcoder
|
defmodule Rambla.Amqp do
@moduledoc """
Default connection implementation for 🐰 Rabbit.
`publish/2` accepts the following options:
- `exchange` [`binary()`, **mandatory**] the exchange to publish to
- `queue` [`binary()`, **optional**] if passed, the queue will be created
and bound to the exchange; it’s slowing down publishing, but safer
for the cold RebbatMQ installation
- `declare?`[`boolean()`, **optional**, _default_: `true`] if false
is passed, the exchange would not be declared; use it if the exchange
already surely exists to speed up the publishing
- `routing_key` [`binary()`, **optional**, _default_: `""`] if passed,
used as a routing key
- `options` [`keyword()`, **optional**, _default_: `[]`] the options
to be passed as is to call to `AMQP.Basic.publish/5`
---
Since `v0.6.0` provides two `mix` tasks:
- `mix rambla.rabbit.exchange` Operations with exchanges in RabbitMQ
- `mix rambla.rabbit.queue` Operations with queues in RabbitMQ
Tasks support arguments to be passed to RabbitMQ instance. Usage example:
```
mix rambla.rabbit.queue declare foo -o durable:true
```
"""
defmodule ChannelPool do
@moduledoc false
@amqp_pool_size Application.get_env(:rambla, :amqp_pool_size, 32)
use Tarearbol.Pool, pool_size: @amqp_pool_size, pickup: :hashring
@spec publish(%Rambla.Connection.Config{}, binary() | map() | list()) ::
{:ok | :replace, Rambla.Connection.Config.t()}
def publish(%Rambla.Connection.Config{conn: conn} = cfg, message) do
id = Enum.random(1..workers_slice())
do_publish({id, conn}, cfg, message)
end
defsynch do_publish(
{id, conn},
%Rambla.Connection.Config{conn: conn, opts: opts} = cfg,
message
) do
message =
case message do
message when is_binary(message) -> message
%{} = message -> Jason.encode!(message)
[{_, _} | _] = message -> message |> Map.new() |> Jason.encode!()
message -> inspect(message)
end
{_, %{chan: %{__struct__: AMQP.Channel} = chan}} =
reply =
case payload!() do
%{conn: ^conn, chan: %{__struct__: AMQP.Channel}} = cfg ->
{:ok, cfg}
%{} = cfg ->
if not is_nil(cfg[:chan]), do: apply(AMQP.Channel, :close, [cfg[:chan]])
{:replace, %{conn: conn, chan: AMQP.Channel |> apply(:open, [conn]) |> elem(1)}}
end
with %{exchange: exchange} <- opts,
declare? <- Map.get(opts, :declare?, true),
if(declare?, do: apply(AMQP.Exchange, :declare, [chan, exchange])),
:ok <- queue!(chan, opts),
do:
apply(AMQP.Basic, :publish, [
chan,
exchange,
Map.get(opts, :routing_key, ""),
message,
Map.get(opts, :options, [])
])
reply
end
@spec queue!(chan :: AMQP.Channel.t(), map()) :: :ok
defp queue!(chan, %{queue: queue, exchange: exchange}) do
with {:ok, %{consumer_count: _, message_count: _, queue: ^queue}} <-
apply(AMQP.Queue, :declare, [chan, queue]),
do: apply(AMQP.Queue, :bind, [chan, queue, exchange])
end
defp queue!(_, %{exchange: _exchange}), do: :ok
@spec workers_slice :: pos_integer()
defp workers_slice,
do: Application.get_env(:rambla, __MODULE__) || invalidate_workers_slice()
@spec invalidate_workers_slice :: pos_integer()
defp invalidate_workers_slice do
poolboy =
Rambla.ConnectionPool
|> DynamicSupervisor.which_children()
|> Enum.reduce_while(nil, fn
{_, pid, :worker, [:poolboy]}, nil -> {:halt, pid}
_, nil -> {:cont, nil}
end)
with pid when is_pid(pid) <- poolboy,
{:ready, num, _, _} when num >= 0 <- :poolboy.status(pid) do
num = div(@amqp_pool_size, num + 1)
Application.put_env(:rambla, __MODULE__, num)
num
else
_ -> @amqp_pool_size
end
end
end
@with_amqp match?({:module, _}, Code.ensure_compiled(AMQP.Channel))
@behaviour Rambla.Connection
@impl Rambla.Connection
def connect(params) when is_list(params) do
if not @with_amqp or is_nil(params[:host]),
do:
raise(Rambla.Exceptions.Connection,
value: params,
expected: "🐰 configuration with :host key"
)
case ChannelPool.start_link() do
{:ok, pool} -> Process.link(pool)
{:error, {:already_started, pool}} -> Process.link(pool)
end
maybe_amqp(params)
end
@impl Rambla.Connection
def publish(%Rambla.Connection.Config{} = conn, message)
when is_binary(message) or is_list(message) or is_map(message),
do: ChannelPool.publish(conn, message)
if @with_amqp do
defp maybe_amqp(params) do
case AMQP.Connection.open(params) do
{:ok, conn} ->
Process.link(conn.pid)
%Rambla.Connection{
conn: %Rambla.Connection.Config{conn: conn},
conn_type: __MODULE__,
conn_pid: conn.pid,
conn_params: params,
errors: []
}
error ->
%Rambla.Connection{
conn: %Rambla.Connection.Config{},
conn_type: __MODULE__,
conn_pid: nil,
conn_params: params,
errors: [error]
}
end
end
else
defp maybe_amqp(params) do
error =
Rambla.Exceptions.Connection.exception(
source: __MODULE__,
info: params,
reason: "🐰 AMQP should be explicitly included to use this functionality"
)
%Rambla.Connection{
conn: %Rambla.Connection.Config{},
conn_type: __MODULE__,
conn_pid: nil,
conn_params: params,
errors: [error]
}
end
end
end
|
lib/rambla/connections/amqp.ex
| 0.881596 | 0.820685 |
amqp.ex
|
starcoder
|
defmodule AfterGlow.ColumnValueController do
use AfterGlow.Web, :controller
alias AfterGlow.ColumnValue
alias JaSerializer.Params
alias AfterGlow.Plugs.Authorization
plug Authorization
plug :authorize!, ColumnValue
plug :scrub_params, "data" when action in [:create, :update]
plug :verify_authorized
def index(conn, %{"filter" => %{"id" =>ids}}) do
ids = ids |> String.split(",")
column_values = Repo.all(from t in ColumnValue, where: t.id in ^ids )
render(conn, :index, data: column_values)
end
def create(conn, %{"data" => data = %{"type" => "column_value", "attributes" => _column_value_params}}) do
changeset = ColumnValue.changeset(%ColumnValue{}, Params.to_attributes(data))
case Repo.insert(changeset) do
{:ok, column_value} ->
conn
|> put_status(:created)
|> put_resp_header("location", column_value_path(conn, :show, column_value))
|> render("show.json-api", data: column_value)
{:error, changeset} ->
conn
|> put_status(:unprocessable_entity)
|> render(:errors, data: changeset)
end
end
def show(conn, %{"id" => id}) do
column_value = Repo.get!(ColumnValue, id)
render(conn, :show, data: column_value)
end
def update(conn, %{"id" => id, "data" => data = %{"type" => "column_value", "attributes" => _column_value_params}}) do
column_value = Repo.get!(ColumnValue, id)
changeset = ColumnValue.changeset(column_value, Params.to_attributes(data))
case Repo.update(changeset) do
{:ok, column_value} ->
render(conn, "show.json-api", data: column_value)
{:error, changeset} ->
conn
|> put_status(:unprocessable_entity)
|> render(:errors, data: changeset)
end
end
def delete(conn, %{"id" => id}) do
column_value = Repo.get!(ColumnValue, id)
# Here we use delete! (with a bang) because we expect
# it to always work (and if it does not, it will raise).
Repo.delete!(column_value)
send_resp(conn, :no_content, "")
end
end
|
web/controllers/column_values_controller.ex
| 0.536556 | 0.415166 |
column_values_controller.ex
|
starcoder
|
defmodule Logger.ErrorHandler do
@moduledoc false
use GenEvent
require Logger
def init({otp?, sasl?, threshold}) do
# We store the logger PID in the state because when we are shutting
# down the Logger application, the Logger process may be terminated
# and then trying to reach it will lead to crashes. So we send a
# message to a PID, instead of named process, to avoid crashes on
# send since this handler will be removed soon by the supervisor.
{:ok, %{otp: otp?, sasl: sasl?, threshold: threshold,
logger: Process.whereis(Logger), last_length: 0,
last_time: :os.timestamp, dropped: 0}}
end
## Handle event
def handle_event({_type, gl, _msg}, state) when node(gl) != node() do
{:ok, state}
end
def handle_event(event, state) do
state = check_threshold(state)
log_event(event, state)
{:ok, state}
end
## Helpers
defp log_event({:error, _gl, {pid, format, data}}, %{otp: true} = state),
do: log_event(:error, :format, pid, {format, data}, state)
defp log_event({:error_report, _gl, {pid, :std_error, format}}, %{otp: true} = state),
do: log_event(:error, :report, pid, {:std_error, format}, state)
defp log_event({:error_report, _gl, {pid, :supervisor_report, data}}, %{sasl: true} = state),
do: log_event(:error, :report, pid, {:supervisor_report, data}, state)
defp log_event({:error_report, _gl, {pid, :crash_report, data}}, %{sasl: true} = state),
do: log_event(:error, :report, pid, {:crash_report, data}, state)
defp log_event({:warning_msg, _gl, {pid, format, data}}, %{otp: true} = state),
do: log_event(:warn, :format, pid, {format, data}, state)
defp log_event({:warning_report, _gl, {pid, :std_warning, format}}, %{otp: true} = state),
do: log_event(:warn, :report, pid, {:std_warning, format}, state)
defp log_event({:info_msg, _gl, {pid, format, data}}, %{otp: true} = state),
do: log_event(:info, :format, pid, {format, data}, state)
defp log_event({:info_report, _gl, {pid, :std_info, format}}, %{otp: true} = state),
do: log_event(:info, :report, pid, {:std_info, format}, state)
defp log_event({:info_report, _gl, {pid, :progress, data}}, %{sasl: true} = state),
do: log_event(:info, :report, pid, {:progress, data}, state)
defp log_event(_, _state),
do: :ok
defp log_event(level, kind, pid, {type, _} = data, state) do
%{level: min_level, truncate: truncate,
utc_log: utc_log?, translators: translators} = Logger.Config.__data__
with log when log != :lt <- Logger.compare_levels(level, min_level),
{:ok, message} <- translate(translators, min_level, level, kind, data, truncate) do
message = Logger.Utils.truncate(message, truncate)
# Mode is always async to avoid clogging the error_logger
meta = [pid: ensure_pid(pid), error_logger: ensure_type(type)]
GenEvent.notify(state.logger,
{level, Process.group_leader(),
{Logger, message, Logger.Utils.timestamp(utc_log?), meta}})
end
:ok
end
defp ensure_type(type) when is_atom(type), do: type
defp ensure_type(_), do: :format
defp ensure_pid(pid) when is_pid(pid), do: pid
defp ensure_pid(_), do: self()
defp check_threshold(%{last_time: last_time, last_length: last_length,
dropped: dropped, threshold: threshold} = state) do
{m, s, _} = current_time = :os.timestamp
current_length = message_queue_length()
cond do
match?({^m, ^s, _}, last_time) and current_length - last_length > threshold ->
count = drop_messages(current_time, 0)
%{state | dropped: dropped + count, last_length: message_queue_length()}
match?({^m, ^s, _}, last_time) ->
state
true ->
_ = if dropped > 0 do
Logger.warn "Logger dropped #{dropped} OTP/SASL messages as it " <>
"exceeded the amount of #{threshold} messages/second"
end
%{state | dropped: 0, last_time: current_time, last_length: current_length}
end
end
defp message_queue_length() do
{:message_queue_len, len} = Process.info(self(), :message_queue_len)
len
end
defp drop_messages({m, s, _} = last_time, count) do
case :os.timestamp do
{^m, ^s, _} ->
receive do
{:notify, _event} -> drop_messages(last_time, count + 1)
after
0 -> count
end
_ ->
count
end
end
defp translate([{mod, fun} | t], min_level, level, kind, data, truncate) do
case apply(mod, fun, [min_level, level, kind, data]) do
{:ok, chardata} -> {:ok, chardata}
:skip -> :skip
:none -> translate(t, min_level, level, kind, data, truncate)
end
end
defp translate([], _min_level, _level, :format, {format, args}, truncate) do
{format, args} = Logger.Utils.inspect(format, args, truncate)
{:ok, :io_lib.format(format, args)}
end
defp translate([], _min_level, _level, :report, {_type, data}, _truncate) do
{:ok, Kernel.inspect(data)}
end
end
|
lib/logger/lib/logger/error_handler.ex
| 0.562898 | 0.448245 |
error_handler.ex
|
starcoder
|
defmodule Slipstream.Socket do
@moduledoc """
A data structure representing a potential websocket client connection
This structure closely resembles `t:Phoenix.Socket.t/0`, but is not
compatible with its functions. All documented functions from this module
are imported by `use Slipstream`.
"""
import Kernel, except: [send: 2, pid: 1]
alias Slipstream.{TelemetryHelper, Socket.Join}
alias Slipstream.Events
if Version.match?(System.version(), ">= 1.8.0") do
@derive {Inspect, only: [:assigns]}
end
defstruct [
:channel_pid,
:socket_pid,
:channel_config,
:response_headers,
metadata: %{},
reconnect_counter: 0,
joins: %{},
assigns: %{}
]
@typedoc """
A socket data structure representing a potential websocket client connection
"""
@typedoc since: "0.1.0"
@type t :: %__MODULE__{
channel_pid: nil | pid(),
socket_pid: pid(),
channel_config: Slipstream.Configuration.t() | nil,
metadata: %{atom() => String.t() | %{String.t() => String.t()}},
reconnect_counter: non_neg_integer(),
assigns: map(),
joins: %{String.t() => %Join{}}
}
@doc false
@spec new() :: t()
def new do
%__MODULE__{
socket_pid: self(),
metadata: %{
socket_id: TelemetryHelper.trace_id(),
joins: %{}
}
}
end
@doc """
Adds key-value pairs to socket assigns
Behaves the same as `Phoenix.Socket.assign/3`
## Examples
iex> assign(socket, :key, :value)
iex> assign(socket, key: :value)
"""
# and indeed the implementation is just about the same as well.
# we can't defdelegate/2 though because the socket module is different
# (hence the struct doesn't match)
@doc since: "0.1.0"
@spec assign(t(), Keyword.t()) :: t()
@spec assign(t(), key :: atom(), value :: any()) :: t()
def assign(%__MODULE__{} = socket, key, value) when is_atom(key) do
assign(socket, [{key, value}])
end
def assign(%__MODULE__{} = socket, attrs)
when is_list(attrs) or is_map(attrs) do
%__MODULE__{socket | assigns: Map.merge(socket.assigns, Map.new(attrs))}
end
@doc """
Updates an existing key in the socket assigns
Raises a `KeyError` if the key is not present in `socket.assigns`.
`func` should be an 1-arity function which takes the existing value at assign
`key` and updates it to a new value. The new value will take the old value's
place in `socket.assigns[key]`.
This function is a useful alternative to `assign/3` when the key is already
present in assigns and is a list, map, or similarly malleable data structure.
## Examples
@impl Slipstream
def handle_cast({:join, topic}, socket) do
socket =
socket
|> update(:topics, &[topic | &1])
|> join(topic)
{:noreply, socket}
end
@impl Slipstream
def handle_call({:join, topic}, from, socket) do
socket =
socket
|> update(:join_requests, &Map.put(&1, topic, from))
|> join(topic)
# note: not replying here so we can provide a synchronous call to a
# topic being joined
{:noreply, socket}
end
@impl Slipstream
def handle_join(topic, response, socket) do
case Map.fetch(socket.assigns.join_requests, topic) do
{:ok, from} -> GenServer.reply(from, {:ok, response})
:error -> :ok
end
{:ok, socket}
end
"""
# again, can't defdelegate/2 because of the socket module being different
# but see the `Phoenix.LiveView.update/3` implementation for the original
# source
@doc since: "0.5.0"
@spec update(t(), key :: atom(), func :: (value :: any() -> value :: any())) ::
t()
def update(%__MODULE__{assigns: assigns} = socket, key, func)
when is_atom(key) and is_function(func, 1) do
case Map.fetch(assigns, key) do
{:ok, value} -> assign(socket, [{key, func.(value)}])
:error -> raise KeyError, key: key, term: assigns
end
end
@doc """
Checks if a channel is currently joined
## Examples
iex> joined?(socket, "room:lobby")
true
"""
@doc since: "0.1.0"
@spec joined?(t(), topic :: String.t()) :: boolean()
def joined?(%__MODULE__{} = socket, topic) when is_binary(topic) do
join_status(socket, topic) == :joined
end
@doc """
Checks the status of a join request
When a join is requested with `Slipstream.join/3`, the join request is
considered to be in the `:requested` state. Once the topic is successfully
joined, it is considered `:joined` until closed. If there is a failure to
join the topic, if the topic crashes, or if the topic is left after being
joined, the status of the join is considered `:closed`. Finally, if a topic
has not been requested in a join so far for a socket, the status is `nil`.
Notably, the status of a join will not automatically change to `:joined` once
the remote server replies with successful join. Either the join must be
awaited with `Slipstream.await_join/2` or the status may be checked later
in the `c:Slipstream.handle_join/3` callback.
## Examples
iex> socket = join(socket, "room:lobby")
iex> join_status(socket, "room:lobby")
:requested
iex> {:ok, socket, _join_response} = await_join(socket, "room:lobby")
iex> join_status(socket, "room:lobby")
:joined
"""
@doc since: "0.1.0"
@spec join_status(t(), topic :: String.t()) ::
:requested | :joined | :closed | nil
def join_status(%__MODULE__{} = socket, topic) when is_binary(topic) do
case Map.fetch(socket.joins, topic) do
{:ok, %Join{status: status}} -> status
:error -> nil
end
end
@doc """
Checks if a socket is connected to a remote websocket host
## Examples
iex> socket = connect(socket, uri: "ws://example.org")
iex> socket = await_connect!(socket)
iex> connected?(socket)
true
"""
@doc since: "0.1.0"
@spec connected?(t()) :: boolean()
def connected?(%__MODULE__{} = socket),
do: socket |> channel_pid() |> is_pid()
@doc """
Gets the process ID of the connection
The slipstream implementor module is not the same process as the GenServer
which interfaces with the remote server for websocket communication. This
other process, the Slipstream.Connection process, interfaces with `:gun`
and communicates with the implementor module by puassing messages (mostly
with `Kernel.send/2`.
It can be useful to have access to this pid for niche purposes, like
sending a fake disconnect message or for debugging (e.g. with
`:sys.get_state/1`)
## Examples
iex> Slipstream.Socket.channel_pid(socket)
#PID<0.1.2>
"""
@doc since: "0.1.0"
@spec channel_pid(t()) :: pid() | nil
def channel_pid(%__MODULE__{channel_pid: pid}) do
if is_pid(pid) and Process.alive?(pid), do: pid, else: nil
end
## helper functions for implementing Slipstream
@doc false
def send(%__MODULE__{} = socket, message) do
if pid = channel_pid(socket), do: Kernel.send(pid, message)
socket
end
@doc false
def call(%__MODULE__{} = socket, message, timeout) do
if pid = channel_pid(socket) do
{:ok, GenServer.call(pid, message, timeout)}
else
{:error, :not_connected}
end
end
@doc false
def put_join_config(%__MODULE__{} = socket, topic, params) do
join = Join.new(topic, params)
%__MODULE__{socket | joins: Map.put_new(socket.joins, topic, join)}
end
# potentially changes a socket by applying an event to it
@doc false
@spec apply_event(t(), struct()) :: t()
def apply_event(socket, event)
def apply_event(socket, %Events.ChannelConnected{} = event) do
socket = TelemetryHelper.conclude_connect(socket, event)
%__MODULE__{
socket
| channel_pid: event.pid,
channel_config: event.config || socket.channel_config,
reconnect_counter: 0
}
end
def apply_event(socket, %Events.TopicJoinSucceeded{topic: topic} = event) do
socket
|> TelemetryHelper.conclude_join(event)
|> put_in([Access.key(:joins), topic, Access.key(:status)], :joined)
|> put_in([Access.key(:joins), topic, Access.key(:rejoin_counter)], 0)
end
def apply_event(socket, %event{topic: topic})
when event in [
Events.TopicLeft,
Events.TopicJoinFailed,
Events.TopicJoinClosed
] do
put_in(socket, [Access.key(:joins), topic, Access.key(:status)], :closed)
end
def apply_event(socket, %Events.ChannelClosed{}) do
%__MODULE__{
socket
| channel_pid: nil,
joins:
Enum.into(socket.joins, %{}, fn {topic, join} ->
{topic, %Join{join | status: :closed}}
end)
}
end
def apply_event(socket, _event), do: socket
@doc false
@spec next_reconnect_time(t()) :: {non_neg_integer(), t()}
def next_reconnect_time(%__MODULE__{} = socket) do
socket = update_in(socket, [Access.key(:reconnect_counter)], &(&1 + 1))
time =
retry_time(
socket.channel_config.reconnect_after_msec,
socket.reconnect_counter - 1
)
{time, socket}
end
@doc false
@spec next_rejoin_time(t(), String.t()) :: {non_neg_integer(), t()}
def next_rejoin_time(socket, topic) do
socket =
update_in(
socket,
[Access.key(:joins), topic, Access.key(:rejoin_counter)],
&(&1 + 1)
)
time =
retry_time(
socket.channel_config.rejoin_after_msec,
socket.joins[topic].rejoin_counter - 1
)
{time, socket}
end
defp retry_time(backoff_times, try_number) do
# when we hit the end of the list, we repeat the last value in the list
default = Enum.at(backoff_times, -1)
Enum.at(backoff_times, try_number, default)
end
end
|
lib/slipstream/socket.ex
| 0.902734 | 0.483405 |
socket.ex
|
starcoder
|
defmodule ShEx.ShapeMap.Decoder do
@moduledoc !"""
Decoder for standard representation format for ShapeMaps specified in <https://shexspec.github.io/shape-map/>.
"""
import ShEx.Utils
alias RDF.{IRI, BlankNode, Literal}
def decode(content, opts \\ []) do
with {:ok, tokens, _} <- tokenize(content),
{:ok, ast} <- parse(tokens) do
build_shape_map(ast, opts)
else
{:error, {error_line, :shape_map_lexer, error_descriptor}, _error_line_again} ->
{:error,
"ShapeMap scanner error on line #{error_line}: #{error_description(error_descriptor)}"}
{:error, {error_line, :shape_map_parser, error_descriptor}} ->
{:error,
"ShapeMap parser error on line #{error_line}: #{error_description(error_descriptor)}"}
end
end
defp error_description(error_descriptor) when is_list(error_descriptor) do
error_descriptor
|> Stream.map(&to_string/1)
|> Enum.join("")
end
defp error_description(error_descriptor), do: inspect(error_descriptor)
defp tokenize(content), do: content |> to_charlist |> :shape_map_lexer.string()
defp parse([]), do: {:ok, []}
defp parse(tokens), do: tokens |> :shape_map_parser.parse()
defp build_shape_map(shape_associations_ast, opts) do
with {:ok, associations} <-
map(shape_associations_ast, &build_association/2, opts) do
{:ok, ShEx.ShapeMap.new(associations)}
end
end
defp build_association({{:node, node_ast}, shape_ast}, opts) do
with {:ok, node} <- build_node(node_ast, opts),
{:ok, shape} <- build_shape(shape_ast, opts) do
{:ok, ShEx.ShapeMap.Association.new(node, shape)}
end
end
defp build_association({{:triple_pattern, triple_pattern_ast}, shape_ast}, opts) do
with {:ok, triple_pattern} <- build_triple_pattern(triple_pattern_ast, opts),
{:ok, shape} <- build_shape(shape_ast, opts) do
{:ok, ShEx.ShapeMap.Association.new(triple_pattern, shape)}
end
end
defp build_shape(:start, _opts), do: {:ok, :start}
defp build_shape(node, opts), do: build_node(node, opts)
defp build_node(%IRI{} = iri, _opts), do: {:ok, iri}
defp build_node(%BlankNode{} = bnode, _opts), do: {:ok, bnode}
defp build_node(%Literal{} = literal, _opts), do: {:ok, literal}
defp build_node({{:string_literal_quote, _line, value}, {:datatype, datatype}}, opts) do
with {:ok, datatype} <- build_node(datatype, opts) do
{:ok, RDF.literal(value, datatype: datatype)}
end
end
defp build_triple_pattern({subject_ast, predicate_ast, object_ast}, opts) do
with {:ok, subject_node_pattern} <- build_node_pattern(subject_ast, opts),
{:ok, predicate_node_pattern} <- build_predicate_pattern(predicate_ast, opts),
{:ok, object_node_pattern} <- build_node_pattern(object_ast, opts) do
{:ok, {subject_node_pattern, predicate_node_pattern, object_node_pattern}}
end
end
defp build_node_pattern(keyword, _opts) when is_atom(keyword), do: {:ok, keyword}
defp build_node_pattern(node_pattern_ast, opts), do: build_node(node_pattern_ast, opts)
defp build_predicate_pattern(:rdf_type, _opts), do: {:ok, RDF.type()}
defp build_predicate_pattern(iri, _opts), do: {:ok, iri}
end
|
lib/shex/shape_map/decoder.ex
| 0.773559 | 0.564038 |
decoder.ex
|
starcoder
|
defmodule Poison.SyntaxError do
defexception [:message, :token]
def exception(opts) do
message = if token = opts[:token] do
"Unexpected token: #{token}"
else
"Unexpected end of input"
end
%Poison.SyntaxError{message: message, token: token}
end
end
defmodule Poison.Parser do
@moduledoc """
An ECMA 404 conforming JSON parser.
See: http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf
"""
if Application.get_env(:poison, :native) do
@compile :native
end
use Bitwise
alias Poison.SyntaxError
@type t :: nil | true | false | list | float | integer | String.t | map
@spec parse(iodata, Keyword.t) :: {:ok, t} | {:error, :invalid}
| {:error, {:invalid, String.t}}
def parse(iodata, options \\ []) do
string = IO.iodata_to_binary(iodata)
{value, rest} = value(skip_whitespace(string), options[:keys])
case skip_whitespace(rest) do
"" -> {:ok, value}
other -> syntax_error(other)
end
catch
:invalid ->
{:error, :invalid}
{:invalid, token} ->
{:error, {:invalid, token}}
end
@spec parse!(iodata, Keyword.t) :: t
def parse!(iodata, options \\ []) do
case parse(iodata, options) do
{:ok, value} ->
value
{:error, :invalid} ->
raise SyntaxError
{:error, {:invalid, token}} ->
raise SyntaxError, token: token
end
end
defp value("\"" <> rest, _keys), do: string_continue(rest, [])
defp value("{" <> rest, keys), do: object_pairs(skip_whitespace(rest), keys, [])
defp value("[" <> rest, keys), do: array_values(skip_whitespace(rest), keys, [])
defp value("null" <> rest, _keys), do: {nil, rest}
defp value("true" <> rest, _keys), do: {true, rest}
defp value("false" <> rest, _keys), do: {false, rest}
defp value(<<char, _ :: binary>> = string, _keys) when char in '-0123456789' do
number_start(string)
end
defp value(other, _keys), do: syntax_error(other)
## Objects
defp object_pairs("\"" <> rest, keys, acc) do
{name, rest} = string_continue(rest, [])
{value, rest} = case skip_whitespace(rest) do
":" <> rest -> value(skip_whitespace(rest), keys)
other -> syntax_error(other)
end
acc = [{object_name(name, keys), value} | acc]
case skip_whitespace(rest) do
"," <> rest -> object_pairs(skip_whitespace(rest), keys, acc)
"}" <> rest -> {:maps.from_list(acc), rest}
other -> syntax_error(other)
end
end
defp object_pairs("}" <> rest, _, []) do
{:maps.new, rest}
end
defp object_pairs(other, _, _), do: syntax_error(other)
defp object_name(name, :atoms), do: String.to_atom(name)
defp object_name(name, :atoms!), do: String.to_existing_atom(name)
defp object_name(name, _keys), do: name
## Arrays
defp array_values("]" <> rest, _, []) do
{[], rest}
end
defp array_values(string, keys, acc) do
{value, rest} = value(string, keys)
acc = [value | acc]
case skip_whitespace(rest) do
"," <> rest -> array_values(skip_whitespace(rest), keys, acc)
"]" <> rest -> {:lists.reverse(acc), rest}
other -> syntax_error(other)
end
end
## Numbers
defp number_start("-" <> rest) do
case rest do
"0" <> rest -> number_frac(rest, ["-0"])
rest -> number_int(rest, [?-])
end
end
defp number_start("0" <> rest) do
number_frac(rest, [?0])
end
defp number_start(string) do
number_int(string, [])
end
defp number_int(<<char, _ :: binary>> = string, acc) when char in '123456789' do
{digits, rest} = number_digits(string)
number_frac(rest, [acc, digits])
end
defp number_int(other, _), do: syntax_error(other)
defp number_frac("." <> rest, acc) do
{digits, rest} = number_digits(rest)
number_exp(rest, true, [acc, ?., digits])
end
defp number_frac(string, acc) do
number_exp(string, false, acc)
end
defp number_exp(<<e>> <> rest, frac, acc) when e in 'eE' do
e = if frac, do: ?e, else: ".0e"
case rest do
"-" <> rest -> number_exp_continue(rest, [acc, e, ?-])
"+" <> rest -> number_exp_continue(rest, [acc, e])
rest -> number_exp_continue(rest, [acc, e])
end
end
defp number_exp(string, frac, acc) do
{number_complete(acc, frac), string}
end
defp number_exp_continue(rest, acc) do
{digits, rest} = number_digits(rest)
{number_complete([acc, digits], true), rest}
end
defp number_complete(iolist, false) do
IO.iodata_to_binary(iolist) |> String.to_integer
end
defp number_complete(iolist, true) do
IO.iodata_to_binary(iolist) |> String.to_float
end
defp number_digits(<<char>> <> rest = string) when char in '0123456789' do
count = number_digits_count(rest, 1)
<<digits :: binary-size(count), rest :: binary>> = string
{digits, rest}
end
defp number_digits(other), do: syntax_error(other)
defp number_digits_count(<<char>> <> rest, acc) when char in '0123456789' do
number_digits_count(rest, acc + 1)
end
defp number_digits_count(_, acc), do: acc
## Strings
defp string_continue("\"" <> rest, acc) do
{IO.iodata_to_binary(acc), rest}
end
defp string_continue("\\" <> rest, acc) do
string_escape(rest, acc)
end
defp string_continue("", _), do: throw(:invalid)
defp string_continue(string, acc) do
n = string_chunk_size(string, 0)
<<chunk :: binary-size(n), rest :: binary>> = string
string_continue(rest, [acc, chunk])
end
for {seq, char} <- Enum.zip('"\\ntr/fb', '"\\\n\t\r/\f\b') do
defp string_escape(<<unquote(seq)>> <> rest, acc) do
string_continue(rest, [acc, unquote(char)])
end
end
# http://www.ietf.org/rfc/rfc2781.txt
# http://perldoc.perl.org/Encode/Unicode.html#Surrogate-Pairs
# http://mathiasbynens.be/notes/javascript-encoding#surrogate-pairs
defp string_escape(<<?u, a1, b1, c1, d1, "\\u", a2, b2, c2, d2>> <> rest, acc)
when a1 in 'dD' and a2 in 'dD'
and (b1 in '89abAB')
and (b2 in ?c..?f or b2 in ?C..?F) \
do
hi = List.to_integer([a1, b1, c1, d1], 16)
lo = List.to_integer([a2, b2, c2, d2], 16)
codepoint = 0x10000 + ((hi &&& 0x03FF) <<< 10) + (lo &&& 0x03FF)
string_continue(rest, [acc, <<codepoint :: utf8>>])
end
defp string_escape(<<?u, seq :: binary-size(4)>> <> rest, acc) do
string_continue(rest, [acc, <<String.to_integer(seq, 16) :: utf8>> ])
end
defp string_escape(other, _), do: syntax_error(other)
defp string_chunk_size("\"" <> _, acc), do: acc
defp string_chunk_size("\\" <> _, acc), do: acc
defp string_chunk_size(<<char>> <> rest, acc) when char < 0x80 do
string_chunk_size(rest, acc + 1)
end
defp string_chunk_size(<<codepoint :: utf8>> <> rest, acc) do
string_chunk_size(rest, acc + string_codepoint_size(codepoint))
end
defp string_chunk_size(other, _), do: syntax_error(other)
defp string_codepoint_size(codepoint) when codepoint < 0x800, do: 2
defp string_codepoint_size(codepoint) when codepoint < 0x10000, do: 3
defp string_codepoint_size(_), do: 4
## Whitespace
defp skip_whitespace(<<char>> <> rest) when char in '\s\n\t\r' do
skip_whitespace(rest)
end
defp skip_whitespace(string), do: string
## Errors
defp syntax_error(<<token :: utf8>> <> _) do
throw({:invalid, <<token>>})
end
defp syntax_error(_) do
throw(:invalid)
end
end
|
issues/deps/poison/lib/poison/parser.ex
| 0.648689 | 0.517449 |
parser.ex
|
starcoder
|
defmodule OpenIDConnect do
@moduledoc """
Handles a majority of the life-cycle concerns with [OpenID Connect](http://openid.net/connect/)
"""
@typedoc """
URI as a string
"""
@type uri :: String.t()
@typedoc """
JSON Web Token
See: https://jwt.io/introduction/
"""
@type jwt :: String.t()
@typedoc """
The provider name as an atom
Example: `:google`
This atom should match what you've used in your application config
"""
@type provider :: atom
@typedoc """
The payload of user data from the provider
"""
@type claims :: map
@typedoc """
The name of the genserver
This is optional and will default to `:openid_connect` unless overridden
"""
@type name :: atom
@typedoc """
Query param map
"""
@type params :: map
@typedoc """
The success tuple
The 2nd element will be the relevant value to work with
"""
@type success(value) :: {:ok, value}
@typedoc """
A string reason for an error failure
"""
@type reason :: String.t() | %HTTPoison.Error{} | %HTTPoison.Response{}
@typedoc """
An error tuple
The 2nd element will indicate which function failed
The 3rd element will give details of the failure
"""
@type error(name) :: {:error, name, reason}
@typedoc """
A provider's documents
* discovery_document: the provider's discovery document for OpenID Connect
* jwk: the provider's certificates converted into a JOSE JSON Web Key
* remaining_lifetime: how long the provider's JWK is valid for
"""
@type documents :: %{
discovery_document: map,
jwk: JOSE.JWK.t(),
remaining_lifetime: integer | nil
}
@spec authorization_uri(provider, params, name) :: uri
@doc """
Builds the authorization URI according to the spec in the providers discovery document
The `params` option can be used to add additional query params to the URI
Example:
OpenIDConnect.authorization_uri(:google, %{"hd" => "dockyard.com"})
> It is *highly suggested* that you add the `state` param for security reasons. Your
> OpenID Connect provider should have more information on this topic.
"""
def authorization_uri(provider, params \\ %{}, name \\ :openid_connect) do
document = discovery_document(provider, name)
config = config(provider, name)
uri = Map.get(document, "authorization_endpoint")
params =
Map.merge(
%{
client_id: client_id(config),
redirect_uri: redirect_uri(config),
response_type: response_type(provider, config, name),
scope: normalize_scope(provider, config[:scope])
},
params
)
build_uri(uri, params)
end
@spec fetch_tokens(provider, params, name) :: success(map) | error(:fetch_tokens)
@doc """
Fetches the authentication tokens from the provider
The `params` option should at least include the key/value pairs of the `response_type` that
was requested during authorization. `params` may also include any one-off overrides for token
fetching.
"""
def fetch_tokens(provider, params, name \\ :openid_connect)
def fetch_tokens(provider, code, name) when is_binary(code) do
IO.warn(
"Deprecation: `OpenIDConnect.fetch_tokens/3` no longer takes a binary as the 2nd argument. Please refer to the docs for the new API."
)
fetch_tokens(provider, %{code: code}, name)
end
def fetch_tokens(provider, params, name) do
uri = access_token_uri(provider, name)
config = config(provider, name)
form_body =
Map.merge(
%{
client_id: client_id(config),
client_secret: client_secret(config),
grant_type: "authorization_code",
redirect_uri: redirect_uri(config)
},
params
)
|> Map.to_list()
headers = [{"Content-Type", "application/x-www-form-urlencoded"}]
with {:ok, %HTTPoison.Response{status_code: status_code} = resp} when status_code in 200..299 <-
http_client().post(uri, {:form, form_body}, headers, http_client_options()),
{:ok, json} <- Jason.decode(resp.body),
{:ok, json} <- assert_json(json) do
{:ok, json}
else
{:ok, resp} -> {:error, :fetch_tokens, resp}
{:error, reason} -> {:error, :fetch_tokens, reason}
end
end
@spec verify(provider, jwt, name) :: success(claims) | error(:verify)
@doc """
Verifies the validity of the JSON Web Token (JWT)
This verification will assert the token's encryption against the provider's
JSON Web Key (JWK)
"""
def verify(provider, jwt, name \\ :openid_connect) do
jwk = jwk(provider, name)
with {:ok, protected} <- peek_protected(jwt),
{:ok, decoded_protected} <- Jason.decode(protected),
{:ok, token_alg} <- Map.fetch(decoded_protected, "alg"),
{true, claims, _jwk} <- do_verify(jwk, token_alg, jwt) do
Jason.decode(claims)
else
{:error, %Jason.DecodeError{}} ->
{:error, :verify, "token claims did not contain a JSON payload"}
{:error, :peek_protected} ->
{:error, :verify, "invalid token format"}
:error ->
{:error, :verify, "no `alg` found in token"}
{false, _claims, _jwk} ->
{:error, :verify, "verification failed"}
_ ->
{:error, :verify, "verification error"}
end
end
@spec update_documents(list) :: success(documents) | error(:update_documents)
@doc """
Requests updated documents from the provider
This function is used by `OpenIDConnect.Worker` for document updates
according to the lifetime returned by the provider
"""
def update_documents(config) do
uri = discovery_document_uri(config)
with {:ok, discovery_document, _} <- fetch_resource(uri),
{:ok, certs, remaining_lifetime} <- fetch_resource(discovery_document["jwks_uri"]),
{:ok, jwk} <- from_certs(certs) do
{:ok,
%{
discovery_document: normalize_discovery_document(discovery_document),
jwk: jwk,
remaining_lifetime: remaining_lifetime
}}
else
{:error, reason} -> {:error, :update_documents, reason}
end
end
@doc false
def normalize_discovery_document(discovery_document) do
# claims_supported may be missing as it is marked RECOMMENDED by the spec, default to an empty list
sorted_claims_supported =
discovery_document
|> Map.get("claims_supported", [])
|> Enum.sort()
# response_types_supported's presence is REQUIRED by the spec, crash when missing
sorted_response_types_supported =
discovery_document
|> Map.get("response_types_supported")
|> Enum.map(fn response_type ->
response_type
|> String.split()
|> Enum.sort()
|> Enum.join(" ")
end)
Map.merge(discovery_document, %{
"claims_supported" => sorted_claims_supported,
"response_types_supported" => sorted_response_types_supported
})
end
defp peek_protected(jwt) do
try do
{:ok, JOSE.JWS.peek_protected(jwt)}
rescue
_ -> {:error, :peek_protected}
end
end
defp do_verify(%JOSE.JWK{keys: {:jose_jwk_set, jwks}}, token_alg, jwt) do
Enum.find_value(jwks, {false, "{}", jwt}, fn jwk ->
jwk
|> JOSE.JWK.from()
|> do_verify(token_alg, jwt)
|> case do
{false, _claims, _jwt} -> false
verified_claims -> verified_claims
end
end)
end
defp do_verify(%JOSE.JWK{} = jwk, token_alg, jwt),
do: JOSE.JWS.verify_strict(jwk, [token_alg], jwt)
defp from_certs(certs) do
try do
{:ok, JOSE.JWK.from(certs)}
rescue
_ ->
{:error, "certificates bad format"}
end
end
defp discovery_document(provider, name) do
GenServer.call(name, {:discovery_document, provider})
end
defp jwk(provider, name) do
GenServer.call(name, {:jwk, provider})
end
defp config(provider, name) do
GenServer.call(name, {:config, provider})
end
defp access_token_uri(provider, name) do
Map.get(discovery_document(provider, name), "token_endpoint")
end
defp client_id(config) do
Keyword.get(config, :client_id)
end
defp client_secret(config) do
Keyword.get(config, :client_secret)
end
defp redirect_uri(config) do
Keyword.get(config, :redirect_uri)
end
defp response_type(provider, config, name) do
response_type =
config
|> Keyword.get(:response_type)
|> normalize_response_type(provider)
response_types_supported = response_types_supported(provider, name)
cond do
response_type in response_types_supported ->
response_type
true ->
raise ArgumentError,
message: """
Requested response type (#{response_type}) not supported by provider (#{provider}).
Supported types:
#{Enum.join(response_types_supported, "\n")}
"""
end
end
defp normalize_response_type(response_type, provider)
when is_nil(response_type) or response_type == [] do
raise ArgumentError, "no response_type has been defined for provider `#{provider}`"
end
defp normalize_response_type(response_type, provider) when is_binary(response_type) do
response_type
|> String.split()
|> normalize_response_type(provider)
end
defp normalize_response_type(response_type, _provider) when is_list(response_type) do
response_type
|> Enum.sort()
|> Enum.join(" ")
end
defp response_types_supported(provider, name) do
provider
|> discovery_document(name)
|> Map.get("response_types_supported")
end
defp discovery_document_uri(config) do
Keyword.get(config, :discovery_document_uri)
end
defp fetch_resource(uri) do
with {:ok, %HTTPoison.Response{status_code: status_code} = resp} when status_code in 200..299 <-
http_client().get(uri, [], http_client_options()),
{:ok, json} <- Jason.decode(resp.body),
{:ok, json} <- assert_json(json) do
{:ok, json, remaining_lifetime(resp.headers)}
else
{:ok, resp} -> {:error, resp}
error -> error
end
end
defp build_uri(uri, params) do
query = URI.encode_query(params)
uri
|> URI.merge("?#{query}")
|> URI.to_string()
end
defp assert_json(%{"error" => reason}), do: {:error, reason}
defp assert_json(json), do: {:ok, json}
@spec remaining_lifetime([{String.t(), String.t()}]) :: integer | nil
defp remaining_lifetime(headers) do
with headers = Enum.into(headers, %{}),
{:ok, max_age} <- find_max_age(headers),
{:ok, age} <- find_age(headers) do
max_age - age
else
_ -> nil
end
end
defp normalize_scope(provider, scopes) when is_nil(scopes) or scopes == [] do
raise ArgumentError, "no scopes have been defined for provider `#{provider}`"
end
defp normalize_scope(_provider, scopes) when is_binary(scopes), do: scopes
defp normalize_scope(_provider, scopes) when is_list(scopes), do: Enum.join(scopes, " ")
defp find_max_age(headers) when is_map(headers) do
case Regex.run(~r"(?<=max-age=)\d+", Map.get(headers, "Cache-Control", "")) do
[max_age] -> {:ok, String.to_integer(max_age)}
_ -> :error
end
end
defp find_age(headers) when is_map(headers) do
case Map.get(headers, "Age") do
nil -> :error
age -> {:ok, String.to_integer(age)}
end
end
defp http_client do
Application.get_env(:openid_connect, :http_client, HTTPoison)
end
defp http_client_options do
Application.get_env(:openid_connect, :http_client_options, [])
end
end
|
lib/openid_connect.ex
| 0.897558 | 0.495484 |
openid_connect.ex
|
starcoder
|
defmodule Sentix.Cache do
@moduledoc """
This module just provides a cache interface which can back multiple Sentix
watchers, to make sure that we have some form of persistence (rather than
relying on the developer to remember to reconnect on crashes).
Currently the only provided functions are based around subscriber storage (in
order to persist across crashes), and paths of binaries to avoid having to look
for them on every execution.
"""
@doc """
Adds a subscriber against the provided Sentix name.
This is a convenience method to avoid having to check whether the list includes
the provided subscriber every time we wish to add a subscriber (because we
don't want to duplicate messages to the subscriber).
"""
@spec add_subscriber(name :: atom, subs :: [ pid ], sub :: pid) :: subs :: [ pid ]
def add_subscriber(name, subs, sub) do
sub_list = if Enum.member?(subs, sub) do
subs
else
[ sub | subs ]
end
set_subscribers(name, sub_list)
end
@doc """
Retrieves the list of subscribers for a provided Sentix name.
This simply hits the backing cache for the provided name, and returns an empty
list if the name does not exist inside the cache.
"""
@spec get_subscribers(name :: atom) :: subscribers :: [ pid ]
def get_subscribers(name) do
Cachex.get!(Sentix, name) || []
end
@doc """
Sets the subscribers for a given Sentix watcher.
This will write the subscribers into the cache, and then return the list of
persisted subscribers for convenience.
"""
@spec set_subscribers(name :: atom, subscribers :: [ pid ]) :: subscribers :: [ pid ]
def set_subscribers(name, subscribers) do
Cachex.set!(Sentix, name, subscribers) && subscribers
end
@doc """
Locates a binary on the host system, if possible.
Once the binary has been located, it's stored inside the cache to speed up future
lookups. We use `:os.find_executable/1` under the hood to locate the binary.
"""
@spec find_binary(name :: [ char ]) ::
{ :ok, path :: binary } |
{ :error, reason :: binary }
def find_binary(name) do
case Cachex.get!(Sentix, name, fallback: &do_find_binary/1) do
nil -> { :error, :missing_binary }
val -> { :ok, val }
end
end
# Internal fallback function for use when a binary has no entry inside the
# cache. This function is used to generate the initial entry for the cache.
defp do_find_binary(key) do
case :os.find_executable(key) do
false -> nil
value -> to_string(value)
end
end
end
|
lib/sentix/cache.ex
| 0.774583 | 0.503418 |
cache.ex
|
starcoder
|
defmodule Timber.Plug.Event do
@moduledoc """
Automatically logs metadata information about HTTP requests
and responses in Plug-based frameworks like Phoenix.
Whether you use Plug by itself or as part of a framework like Phoenix,
adding this plug to your pipeline will automatically create events
for incoming HTTP requests and responses for your log statements.
Note: If you're using `Timber.Plug.HTTPContext`, that plug should come before
`Timber.Plug.Event` in any pipeline. This will give you the best results.
## Adding the Plug
`Timber.Plug.Event` can be added to your plug pipeline using the standard
`Plug.Builder.plug/2` macro. The point at which you place it determines
what state Timber will receive the connection in, therefore it's
recommended you place it as close to the origin of the request as
possible.
### Plug (Standalone or Plug.Router)
If you are using Plug without a framework, your setup will vary depending
on your architecture. The call to `plug Timber.Plug.Event` should be grouped
with any other plugs you call prior to performing business logic.
Timber expects query paramters to have already been fetched on the
connection using `Plug.Conn.fetch_query_params/2`.
### Phoenix
Phoenix's flexibility means there are multiple points in the plug pipeline
where the `Timber.Plug.Event` can be inserted. The recommended place is in
a `:logging` pipeline in your router, but if you have more complex needs
you can also place the plug in an endpoint or a controller.
```elixir
defmodule MyApp.Router do
use MyApp.Web, :router
pipeline :logging do
plug Timber.Plug.Event
end
scope "/api", MyApp do
pipe_through :logging
end
end
```
If you place the plug call in your endpoint, you will need to make sure
that it appears after `Plug.RequestId` (if you are using it) but before
the call to your router.
## Issues with Plug.ErrorHandler
If you are using `Plug.ErrorHandler`, you will not see a response
event if an exception is raised. This is because of how the error
handler works in practice. In order to capture information about the
response, Timber registers a callback to be used before Plug actually
sends the response. Plug stores this information on the
connection struct. When an exception is raised, the methodology used
by the error handler will reset the conn to the state it was first
accepted by the router.
"""
@behaviour Plug
require Logger
alias Timber.JSON
alias Timber.Timer
@doc false
@impl true
def init(opts) do
opts
end
@doc false
@impl true
def call(conn, opts) do
timer = Timer.start()
log_level = Keyword.get(opts, :log_level, :info)
request_id_header_name = Keyword.get(opts, :request_id_header, "x-request-id")
request_id_header = Timber.Plug.get_request_id(conn, request_id_header_name)
request_id = request_id_from_header(request_id_header)
method = conn.method
host = conn.host
port = conn.port
scheme = conn.scheme
path = conn.request_path
headers = List.flatten([request_id_header | conn.req_headers])
headers_json = headers_to_headers_json(headers)
query_string = conn.query_string
event = %{
http_request_received: %{
headers_json: headers_json,
host: host,
method: method,
path: path,
port: port,
query_string: query_string,
request_id: request_id,
scheme: scheme
}
}
message =
if path do
["Received ", method, " ", path]
else
["Received ", method]
end
Logger.log(log_level, message, event: event)
conn
|> Plug.Conn.put_private(:timber_opts, opts)
|> Plug.Conn.put_private(:timber_timer, timer)
|> Plug.Conn.register_before_send(&log_response_event/1)
end
@spec log_response_event(Plug.Conn.t()) :: Plug.Conn.t()
defp log_response_event(conn) do
duration_ms = Timber.duration_ms(conn.private.timber_timer)
opts = conn.private.timber_opts
log_level = Keyword.get(opts, :log_level, :info)
status = Plug.Conn.Status.code(conn.status)
request_id_header_name = Keyword.get(opts, :request_id_header, "x-request-id")
request_id_header = Timber.Plug.get_request_id(conn, request_id_header_name)
# The response body typing is iodata; it should not be assumed
# to be a binary
bytes = body_bytes(conn.resp_body)
headers = [
{"content-length", Integer.to_string(bytes)}
| conn.resp_headers
]
headers = List.flatten([request_id_header | headers])
headers_json = headers_to_headers_json(headers)
request_id = request_id_from_header(request_id_header)
event = %{
http_response_sent: %{
headers_json: headers_json,
request_id: request_id,
status: status,
duration_ms: duration_ms
}
}
message = [
"Sent ",
Integer.to_string(status),
" response in ",
Timber.format_duration_ms(duration_ms)
]
Logger.log(log_level, message, event: event)
conn
end
defp body_bytes(nil), do: 0
defp body_bytes(body), do: IO.iodata_length(body)
defp request_id_from_header(request_id_header) do
case request_id_header do
[{_, request_id}] -> request_id
[] -> nil
end
end
# Constructs a full path from the given parts
def full_url(scheme, host, path, port, query_string) do
%URI{scheme: scheme, host: host, path: path, port: port, query: query_string}
|> URI.to_string()
end
@spec headers_to_headers_json(Keyword.t()) :: String.t()
def headers_to_headers_json(headers) do
Map.new(headers)
|> JSON.encode_to_binary!()
end
end
|
lib/timber_plug/event.ex
| 0.906978 | 0.74382 |
event.ex
|
starcoder
|
defmodule AWS.Kinesis do
@moduledoc """
Amazon Kinesis Streams Service API Reference
Amazon Kinesis Streams is a managed service that scales elastically for
real time processing of streaming big data.
"""
@doc """
Adds or updates tags for the specified Amazon Kinesis stream. Each stream
can have up to 10 tags.
If tags have already been assigned to the stream, `AddTagsToStream`
overwrites any existing tags that correspond to the specified tag keys.
"""
def add_tags_to_stream(client, input, options \\ []) do
request(client, "AddTagsToStream", input, options)
end
@doc """
Creates an Amazon Kinesis stream. A stream captures and transports data
records that are continuously emitted from different data sources or
*producers*. Scale-out within a stream is explicitly supported by means of
shards, which are uniquely identified groups of data records in a stream.
You specify and control the number of shards that a stream is composed of.
Each shard can support reads up to 5 transactions per second, up to a
maximum data read total of 2 MB per second. Each shard can support writes
up to 1,000 records per second, up to a maximum data write total of 1 MB
per second. You can add shards to a stream if the amount of data input
increases and you can remove shards if the amount of data input decreases.
The stream name identifies the stream. The name is scoped to the AWS
account used by the application. It is also scoped by region. That is, two
streams in two different accounts can have the same name, and two streams
in the same account, but in two different regions, can have the same name.
`CreateStream` is an asynchronous operation. Upon receiving a
`CreateStream` request, Amazon Kinesis immediately returns and sets the
stream status to `CREATING`. After the stream is created, Amazon Kinesis
sets the stream status to `ACTIVE`. You should perform read and write
operations only on an `ACTIVE` stream.
You receive a `LimitExceededException` when making a `CreateStream` request
if you try to do one of the following:
<ul> <li>Have more than five streams in the `CREATING` state at any point
in time.
</li> <li>Create more shards than are authorized for your account.
</li> </ul> For the default shard limit for an AWS account, see [Streams
Limits](http://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
in the *Amazon Kinesis Streams Developer Guide*. If you need to increase
this limit, [contact AWS
Support](http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
You can use `DescribeStream` to check the stream status, which is returned
in `StreamStatus`.
`CreateStream` has a limit of 5 transactions per second per account.
"""
def create_stream(client, input, options \\ []) do
request(client, "CreateStream", input, options)
end
@doc """
Decreases the Amazon Kinesis stream's retention period, which is the length
of time data records are accessible after they are added to the stream. The
minimum value of a stream's retention period is 24 hours.
This operation may result in lost data. For example, if the stream's
retention period is 48 hours and is decreased to 24 hours, any data already
in the stream that is older than 24 hours is inaccessible.
"""
def decrease_stream_retention_period(client, input, options \\ []) do
request(client, "DecreaseStreamRetentionPeriod", input, options)
end
@doc """
Deletes an Amazon Kinesis stream and all its shards and data. You must shut
down any applications that are operating on the stream before you delete
the stream. If an application attempts to operate on a deleted stream, it
will receive the exception `ResourceNotFoundException`.
If the stream is in the `ACTIVE` state, you can delete it. After a
`DeleteStream` request, the specified stream is in the `DELETING` state
until Amazon Kinesis completes the deletion.
**Note:** Amazon Kinesis might continue to accept data read and write
operations, such as `PutRecord`, `PutRecords`, and `GetRecords`, on a
stream in the `DELETING` state until the stream deletion is complete.
When you delete a stream, any shards in that stream are also deleted, and
any tags are dissociated from the stream.
You can use the `DescribeStream` operation to check the state of the
stream, which is returned in `StreamStatus`.
`DeleteStream` has a limit of 5 transactions per second per account.
"""
def delete_stream(client, input, options \\ []) do
request(client, "DeleteStream", input, options)
end
@doc """
Describes the shard limits and usage for the account.
If you update your account limits, the old limits might be returned for a
few minutes.
This operation has a limit of 1 transaction per second per account.
"""
def describe_limits(client, input, options \\ []) do
request(client, "DescribeLimits", input, options)
end
@doc """
Describes the specified Amazon Kinesis stream.
The information returned includes the stream name, Amazon Resource Name
(ARN), creation time, enhanced metric configuration, and shard map. The
shard map is an array of shard objects. For each shard object, there is the
hash key and sequence number ranges that the shard spans, and the IDs of
any earlier shards that played in a role in creating the shard. Every
record ingested in the stream is identified by a sequence number, which is
assigned when the record is put into the stream.
You can limit the number of shards returned by each call. For more
information, see [Retrieving Shards from a
Stream](http://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html)
in the *Amazon Kinesis Streams Developer Guide*.
There are no guarantees about the chronological order shards returned. To
process shards in chronological order, use the ID of the parent shard to
track the lineage to the oldest shard.
This operation has a limit of 10 transactions per second per account.
"""
def describe_stream(client, input, options \\ []) do
request(client, "DescribeStream", input, options)
end
@doc """
Disables enhanced monitoring.
"""
def disable_enhanced_monitoring(client, input, options \\ []) do
request(client, "DisableEnhancedMonitoring", input, options)
end
@doc """
Enables enhanced Amazon Kinesis stream monitoring for shard-level metrics.
"""
def enable_enhanced_monitoring(client, input, options \\ []) do
request(client, "EnableEnhancedMonitoring", input, options)
end
@doc """
Gets data records from an Amazon Kinesis stream's shard.
Specify a shard iterator using the `ShardIterator` parameter. The shard
iterator specifies the position in the shard from which you want to start
reading data records sequentially. If there are no records available in the
portion of the shard that the iterator points to, `GetRecords` returns an
empty list. Note that it might take multiple calls to get to a portion of
the shard that contains records.
You can scale by provisioning multiple shards per stream while considering
service limits (for more information, see [Streams
Limits](http://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
in the *Amazon Kinesis Streams Developer Guide*). Your application should
have one thread per shard, each reading continuously from its stream. To
read from a stream continually, call `GetRecords` in a loop. Use
`GetShardIterator` to get the shard iterator to specify in the first
`GetRecords` call. `GetRecords` returns a new shard iterator in
`NextShardIterator`. Specify the shard iterator returned in
`NextShardIterator` in subsequent calls to `GetRecords`. Note that if the
shard has been closed, the shard iterator can't return more data and
`GetRecords` returns `null` in `NextShardIterator`. You can terminate the
loop when the shard is closed, or when the shard iterator reaches the
record with the sequence number or other attribute that marks it as the
last record to process.
Each data record can be up to 1 MB in size, and each shard can read up to 2
MB per second. You can ensure that your calls don't exceed the maximum
supported size or throughput by using the `Limit` parameter to specify the
maximum number of records that `GetRecords` can return. Consider your
average record size when determining this limit.
The size of the data returned by `GetRecords` varies depending on the
utilization of the shard. The maximum size of data that `GetRecords` can
return is 10 MB. If a call returns this amount of data, subsequent calls
made within the next 5 seconds throw
`ProvisionedThroughputExceededException`. If there is insufficient
provisioned throughput on the shard, subsequent calls made within the next
1 second throw `ProvisionedThroughputExceededException`. Note that
`GetRecords` won't return any data when it throws an exception. For this
reason, we recommend that you wait one second between calls to
`GetRecords`; however, it's possible that the application will get
exceptions for longer than 1 second.
To detect whether the application is falling behind in processing, you can
use the `MillisBehindLatest` response attribute. You can also monitor the
stream using CloudWatch metrics and other mechanisms (see
[Monitoring](http://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html)
in the *Amazon Kinesis Streams Developer Guide*).
Each Amazon Kinesis record includes a value, `ApproximateArrivalTimestamp`,
that is set when a stream successfully receives and stores a record. This
is commonly referred to as a server-side timestamp, whereas a client-side
timestamp is set when a data producer creates or sends the record to a
stream (a data producer is any data source putting data records into a
stream, for example with `PutRecords`). The timestamp has millisecond
precision. There are no guarantees about the timestamp accuracy, or that
the timestamp is always increasing. For example, records in a shard or
across a stream might have timestamps that are out of order.
"""
def get_records(client, input, options \\ []) do
request(client, "GetRecords", input, options)
end
@doc """
Gets an Amazon Kinesis shard iterator. A shard iterator expires five
minutes after it is returned to the requester.
A shard iterator specifies the shard position from which to start reading
data records sequentially. The position is specified using the sequence
number of a data record in a shard. A sequence number is the identifier
associated with every record ingested in the stream, and is assigned when a
record is put into the stream. Each stream has one or more shards.
You must specify the shard iterator type. For example, you can set the
`ShardIteratorType` parameter to read exactly from the position denoted by
a specific sequence number by using the `AT_SEQUENCE_NUMBER` shard iterator
type, or right after the sequence number by using the
`AFTER_SEQUENCE_NUMBER` shard iterator type, using sequence numbers
returned by earlier calls to `PutRecord`, `PutRecords`, `GetRecords`, or
`DescribeStream`. In the request, you can specify the shard iterator type
`AT_TIMESTAMP` to read records from an arbitrary point in time,
`TRIM_HORIZON` to cause `ShardIterator` to point to the last untrimmed
record in the shard in the system (the oldest data record in the shard), or
`LATEST` so that you always read the most recent data in the shard.
When you read repeatedly from a stream, use a `GetShardIterator` request to
get the first shard iterator for use in your first `GetRecords` request and
for subsequent reads use the shard iterator returned by the `GetRecords`
request in `NextShardIterator`. A new shard iterator is returned by every
`GetRecords` request in `NextShardIterator`, which you use in the
`ShardIterator` parameter of the next `GetRecords` request.
If a `GetShardIterator` request is made too often, you receive a
`ProvisionedThroughputExceededException`. For more information about
throughput limits, see `GetRecords`, and [Streams
Limits](http://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
in the *Amazon Kinesis Streams Developer Guide*.
If the shard is closed, `GetShardIterator` returns a valid iterator for the
last sequence number of the shard. Note that a shard can be closed as a
result of using `SplitShard` or `MergeShards`.
`GetShardIterator` has a limit of 5 transactions per second per account per
open shard.
"""
def get_shard_iterator(client, input, options \\ []) do
request(client, "GetShardIterator", input, options)
end
@doc """
Increases the Amazon Kinesis stream's retention period, which is the length
of time data records are accessible after they are added to the stream. The
maximum value of a stream's retention period is 168 hours (7 days).
Upon choosing a longer stream retention period, this operation will
increase the time period records are accessible that have not yet expired.
However, it will not make previous data that has expired (older than the
stream's previous retention period) accessible after the operation has been
called. For example, if a stream's retention period is set to 24 hours and
is increased to 168 hours, any data that is older than 24 hours will remain
inaccessible to consumer applications.
"""
def increase_stream_retention_period(client, input, options \\ []) do
request(client, "IncreaseStreamRetentionPeriod", input, options)
end
@doc """
Lists your Amazon Kinesis streams.
The number of streams may be too large to return from a single call to
`ListStreams`. You can limit the number of returned streams using the
`Limit` parameter. If you do not specify a value for the `Limit` parameter,
Amazon Kinesis uses the default limit, which is currently 10.
You can detect if there are more streams available to list by using the
`HasMoreStreams` flag from the returned output. If there are more streams
available, you can request more streams by using the name of the last
stream returned by the `ListStreams` request in the
`ExclusiveStartStreamName` parameter in a subsequent request to
`ListStreams`. The group of stream names returned by the subsequent request
is then added to the list. You can continue this process until all the
stream names have been collected in the list.
`ListStreams` has a limit of 5 transactions per second per account.
"""
def list_streams(client, input, options \\ []) do
request(client, "ListStreams", input, options)
end
@doc """
Lists the tags for the specified Amazon Kinesis stream.
"""
def list_tags_for_stream(client, input, options \\ []) do
request(client, "ListTagsForStream", input, options)
end
@doc """
Merges two adjacent shards in an Amazon Kinesis stream and combines them
into a single shard to reduce the stream's capacity to ingest and transport
data. Two shards are considered adjacent if the union of the hash key
ranges for the two shards form a contiguous set with no gaps. For example,
if you have two shards, one with a hash key range of 276...381 and the
other with a hash key range of 382...454, then you could merge these two
shards into a single shard that would have a hash key range of 276...454.
After the merge, the single child shard receives data for all hash key
values covered by the two parent shards.
`MergeShards` is called when there is a need to reduce the overall capacity
of a stream because of excess capacity that is not being used. You must
specify the shard to be merged and the adjacent shard for a stream. For
more information about merging shards, see [Merge Two
Shards](http://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html)
in the *Amazon Kinesis Streams Developer Guide*.
If the stream is in the `ACTIVE` state, you can call `MergeShards`. If a
stream is in the `CREATING`, `UPDATING`, or `DELETING` state, `MergeShards`
returns a `ResourceInUseException`. If the specified stream does not exist,
`MergeShards` returns a `ResourceNotFoundException`.
You can use `DescribeStream` to check the state of the stream, which is
returned in `StreamStatus`.
`MergeShards` is an asynchronous operation. Upon receiving a `MergeShards`
request, Amazon Kinesis immediately returns a response and sets the
`StreamStatus` to `UPDATING`. After the operation is completed, Amazon
Kinesis sets the `StreamStatus` to `ACTIVE`. Read and write operations
continue to work while the stream is in the `UPDATING` state.
You use `DescribeStream` to determine the shard IDs that are specified in
the `MergeShards` request.
If you try to operate on too many streams in parallel using `CreateStream`,
`DeleteStream`, `MergeShards` or `SplitShard`, you will receive a
`LimitExceededException`.
`MergeShards` has limit of 5 transactions per second per account.
"""
def merge_shards(client, input, options \\ []) do
request(client, "MergeShards", input, options)
end
@doc """
Writes a single data record into an Amazon Kinesis stream. Call `PutRecord`
to send data into the stream for real-time ingestion and subsequent
processing, one record at a time. Each shard can support writes up to 1,000
records per second, up to a maximum data write total of 1 MB per second.
You must specify the name of the stream that captures, stores, and
transports the data; a partition key; and the data blob itself.
The data blob can be any type of data; for example, a segment from a log
file, geographic/location data, website clickstream data, and so on.
The partition key is used by Amazon Kinesis to distribute data across
shards. Amazon Kinesis segregates the data records that belong to a stream
into multiple shards, using the partition key associated with each data
record to determine which shard a given data record belongs to.
Partition keys are Unicode strings, with a maximum length limit of 256
characters for each key. An MD5 hash function is used to map partition keys
to 128-bit integer values and to map associated data records to shards
using the hash key ranges of the shards. You can override hashing the
partition key to determine the shard by explicitly specifying a hash value
using the `ExplicitHashKey` parameter. For more information, see [Adding
Data to a
Stream](http://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
in the *Amazon Kinesis Streams Developer Guide*.
`PutRecord` returns the shard ID of where the data record was placed and
the sequence number that was assigned to the data record.
Sequence numbers increase over time and are specific to a shard within a
stream, not across all shards within a stream. To guarantee strictly
increasing ordering, write serially to a shard and use the
`SequenceNumberForOrdering` parameter. For more information, see [Adding
Data to a
Stream](http://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
in the *Amazon Kinesis Streams Developer Guide*.
If a `PutRecord` request cannot be processed because of insufficient
provisioned throughput on the shard involved in the request, `PutRecord`
throws `ProvisionedThroughputExceededException`.
Data records are accessible for only 24 hours from the time that they are
added to a stream.
"""
def put_record(client, input, options \\ []) do
request(client, "PutRecord", input, options)
end
@doc """
Writes multiple data records into an Amazon Kinesis stream in a single call
(also referred to as a `PutRecords` request). Use this operation to send
data into the stream for data ingestion and processing.
Each `PutRecords` request can support up to 500 records. Each record in the
request can be as large as 1 MB, up to a limit of 5 MB for the entire
request, including partition keys. Each shard can support writes up to
1,000 records per second, up to a maximum data write total of 1 MB per
second.
You must specify the name of the stream that captures, stores, and
transports the data; and an array of request `Records`, with each record in
the array requiring a partition key and data blob. The record size limit
applies to the total size of the partition key and data blob.
The data blob can be any type of data; for example, a segment from a log
file, geographic/location data, website clickstream data, and so on.
The partition key is used by Amazon Kinesis as input to a hash function
that maps the partition key and associated data to a specific shard. An MD5
hash function is used to map partition keys to 128-bit integer values and
to map associated data records to shards. As a result of this hashing
mechanism, all data records with the same partition key map to the same
shard within the stream. For more information, see [Adding Data to a
Stream](http://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
in the *Amazon Kinesis Streams Developer Guide*.
Each record in the `Records` array may include an optional parameter,
`ExplicitHashKey`, which overrides the partition key to shard mapping. This
parameter allows a data producer to determine explicitly the shard where
the record is stored. For more information, see [Adding Multiple Records
with
PutRecords](http://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-putrecords)
in the *Amazon Kinesis Streams Developer Guide*.
The `PutRecords` response includes an array of response `Records`. Each
record in the response array directly correlates with a record in the
request array using natural ordering, from the top to the bottom of the
request and response. The response `Records` array always includes the same
number of records as the request array.
The response `Records` array includes both successfully and unsuccessfully
processed records. Amazon Kinesis attempts to process all records in each
`PutRecords` request. A single record failure does not stop the processing
of subsequent records.
A successfully-processed record includes `ShardId` and `SequenceNumber`
values. The `ShardId` parameter identifies the shard in the stream where
the record is stored. The `SequenceNumber` parameter is an identifier
assigned to the put record, unique to all records in the stream.
An unsuccessfully-processed record includes `ErrorCode` and `ErrorMessage`
values. `ErrorCode` reflects the type of error and can be one of the
following values: `ProvisionedThroughputExceededException` or
`InternalFailure`. `ErrorMessage` provides more detailed information about
the `ProvisionedThroughputExceededException` exception including the
account ID, stream name, and shard ID of the record that was throttled. For
more information about partially successful responses, see [Adding Multiple
Records with
PutRecords](http://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-putrecords)
in the *Amazon Kinesis Streams Developer Guide*.
By default, data records are accessible for only 24 hours from the time
that they are added to an Amazon Kinesis stream. This retention period can
be modified using the `DecreaseStreamRetentionPeriod` and
`IncreaseStreamRetentionPeriod` operations.
"""
def put_records(client, input, options \\ []) do
request(client, "PutRecords", input, options)
end
@doc """
Removes tags from the specified Amazon Kinesis stream. Removed tags are
deleted and cannot be recovered after this operation successfully
completes.
If you specify a tag that does not exist, it is ignored.
"""
def remove_tags_from_stream(client, input, options \\ []) do
request(client, "RemoveTagsFromStream", input, options)
end
@doc """
Splits a shard into two new shards in the Amazon Kinesis stream to increase
the stream's capacity to ingest and transport data. `SplitShard` is called
when there is a need to increase the overall capacity of a stream because
of an expected increase in the volume of data records being ingested.
You can also use `SplitShard` when a shard appears to be approaching its
maximum utilization; for example, the producers sending data into the
specific shard are suddenly sending more than previously anticipated. You
can also call `SplitShard` to increase stream capacity, so that more Amazon
Kinesis applications can simultaneously read data from the stream for
real-time processing.
You must specify the shard to be split and the new hash key, which is the
position in the shard where the shard gets split in two. In many cases, the
new hash key might simply be the average of the beginning and ending hash
key, but it can be any hash key value in the range being mapped into the
shard. For more information about splitting shards, see [Split a
Shard](http://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html)
in the *Amazon Kinesis Streams Developer Guide*.
You can use `DescribeStream` to determine the shard ID and hash key values
for the `ShardToSplit` and `NewStartingHashKey` parameters that are
specified in the `SplitShard` request.
`SplitShard` is an asynchronous operation. Upon receiving a `SplitShard`
request, Amazon Kinesis immediately returns a response and sets the stream
status to `UPDATING`. After the operation is completed, Amazon Kinesis sets
the stream status to `ACTIVE`. Read and write operations continue to work
while the stream is in the `UPDATING` state.
You can use `DescribeStream` to check the status of the stream, which is
returned in `StreamStatus`. If the stream is in the `ACTIVE` state, you can
call `SplitShard`. If a stream is in `CREATING` or `UPDATING` or `DELETING`
states, `DescribeStream` returns a `ResourceInUseException`.
If the specified stream does not exist, `DescribeStream` returns a
`ResourceNotFoundException`. If you try to create more shards than are
authorized for your account, you receive a `LimitExceededException`.
For the default shard limit for an AWS account, see [Streams
Limits](http://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
in the *Amazon Kinesis Streams Developer Guide*. If you need to increase
this limit, [contact AWS
Support](http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
If you try to operate on too many streams simultaneously using
`CreateStream`, `DeleteStream`, `MergeShards`, and/or `SplitShard`, you
receive a `LimitExceededException`.
`SplitShard` has limit of 5 transactions per second per account.
"""
def split_shard(client, input, options \\ []) do
request(client, "SplitShard", input, options)
end
@doc """
Updates the shard count of the specified stream to the specified number of
shards.
Updating the shard count is an asynchronous operation. Upon receiving the
request, Amazon Kinesis returns immediately and sets the status of the
stream to `UPDATING`. After the update is complete, Amazon Kinesis sets the
status of the stream back to `ACTIVE`. Depending on the size of the stream,
the scaling action could take a few minutes to complete. You can continue
to read and write data to your stream while its status is `UPDATING`.
To update the shard count, Amazon Kinesis performs splits and merges and
individual shards. This can cause short-lived shards to be created, in
addition to the final shards. We recommend that you double or halve the
shard count, as this results in the fewest number of splits or merges.
This operation has a rate limit of twice per rolling 24 hour period. You
cannot scale above double your current shard count, scale below half your
current shard count, or exceed the shard limits for your account.
For the default limits for an AWS account, see [Streams
Limits](http://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
in the *Amazon Kinesis Streams Developer Guide*. If you need to increase a
limit, [contact AWS
Support](http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
"""
def update_shard_count(client, input, options \\ []) do
request(client, "UpdateShardCount", input, options)
end
@spec request(map(), binary(), map(), list()) ::
{:ok, Poison.Parser.t | nil, Poison.Response.t} |
{:error, Poison.Parser.t} |
{:error, HTTPoison.Error.t}
defp request(client, action, input, options) do
client = %{client | service: "kinesis"}
host = get_host("kinesis", client)
url = get_url(host, client)
headers = [{"Host", host},
{"Content-Type", "application/x-amz-json-1.1"},
{"X-Amz-Target", "Kinesis_20131202.#{action}"}]
payload = Poison.Encoder.encode(input, [])
headers = AWS.Request.sign_v4(client, "POST", url, headers, payload)
case HTTPoison.post(url, payload, headers, options) do
{:ok, response=%HTTPoison.Response{status_code: 200, body: ""}} ->
{:ok, nil, response}
{:ok, response=%HTTPoison.Response{status_code: 200, body: body}} ->
{:ok, Poison.Parser.parse!(body), response}
{:ok, _response=%HTTPoison.Response{body: body}} ->
error = Poison.Parser.parse!(body)
exception = error["__type"]
message = error["message"]
{:error, {exception, message}}
{:error, %HTTPoison.Error{reason: reason}} ->
{:error, %HTTPoison.Error{reason: reason}}
end
end
defp get_host(endpoint_prefix, client) do
if client.region == "local" do
"localhost"
else
"#{endpoint_prefix}.#{client.region}.#{client.endpoint}"
end
end
defp get_url(host, %{:proto => proto, :port => port}) do
"#{proto}://#{host}:#{port}/"
end
end
|
lib/aws/kinesis.ex
| 0.934724 | 0.775817 |
kinesis.ex
|
starcoder
|
defmodule Valet.Error.TypeMismatch do
@enforce_keys [:trail, :value, :expected]
defstruct @enforce_keys
def new(trail, value, expected),
do: %__MODULE__{trail: trail, value: value, expected: expected}
end
defmodule Valet.Error.NotInSet do
@enforce_keys [:trail, :value, :valid]
defstruct @enforce_keys
def new(trail, value, valid),
do: %__MODULE__{trail: trail, value: value, valid: valid}
end
defmodule Valet.Error.RegexDoesNotMatch do
@enforce_keys [:trail, :value, :regex]
defstruct @enforce_keys
def new(trail, value, regex),
do: %__MODULE__{trail: trail, value: value, regex: regex}
end
defmodule Valet.Error.KeyIsMissing do
@enforce_keys [:trail, :in_value, :key, :val_schema]
defstruct @enforce_keys
def new(trail, in_value, key, val_schema),
do: %__MODULE__{trail: trail, in_value: in_value, key: key, val_schema: val_schema}
end
defmodule Valet.Error.KeysUnknown do
@enforce_keys [:trail, :value, :keys, :valid]
defstruct @enforce_keys
def new(trail, value, keys, valid),
do: %__MODULE__{trail: trail, value: value, keys: keys, valid: valid}
end
defmodule Valet.Error.NotAtLeast do
@enforce_keys [:trail, :value, :min]
defstruct @enforce_keys
def new(trail, value, min),
do: %__MODULE__{trail: trail, value: value, min: min}
end
defmodule Valet.Error.NotAtMost do
@enforce_keys [:trail, :value, :max]
defstruct @enforce_keys
def new(trail, value, max),
do: %__MODULE__{trail: trail, value: value, max: max}
end
defmodule Valet.Error.NotBetween do
@enforce_keys [:trail, :value, :min, :max]
defstruct @enforce_keys
def new(trail, value, min, max),
do: %__MODULE__{trail: trail, value: value, min: min, max: max}
end
defmodule Valet.Error.LengthNot do
@enforce_keys [:trail, :value, :expected]
defstruct @enforce_keys
def new(trail, value, expected),
do: %__MODULE__{trail: trail, value: value, expected: expected}
end
defmodule Valet.Error.LengthNotAtLeast do
@enforce_keys [:trail, :value, :min]
defstruct @enforce_keys
def new(trail, value, min),
do: %__MODULE__{trail: trail, value: value, min: min}
end
defmodule Valet.Error.LengthNotAtMost do
@enforce_keys [:trail, :value, :max]
defstruct @enforce_keys
def new(trail, value, max),
do: %__MODULE__{trail: trail, value: value, max: max}
end
defmodule Valet.Error.LengthNotBetween do
@enforce_keys [:trail, :value, :min, :max]
defstruct @enforce_keys
def new(trail, value, min, max),
do: %__MODULE__{trail: trail, value: value, min: min, max: max}
end
defmodule Valet.Error.Disunion do
@enforce_keys [:trail, :value, :errors]
defstruct @enforce_keys
def new(trail, value, errors),
do: %__MODULE__{trail: trail, value: value, errors: errors}
end
|
lib/errors.ex
| 0.782912 | 0.743401 |
errors.ex
|
starcoder
|
defmodule AisFront.Units.ROT do
alias __MODULE__
alias AisFront.Protocols.Convertible
defstruct value: %Decimal{}, unit: :ms
@si_unit :rad_sec
@unit_si_ratio %{
rad_sec: 1,
deg_sec: :math.pi |> Decimal.cast |> Decimal.div(180),
deg_min: :math.pi |> Decimal.cast |> Decimal.div(180*60)
}
@possible_units Map.keys(@unit_si_ratio) ++ [:ais]
def si_unit(), do: @si_unit
def unit_si_ratio(), do: @unit_si_ratio
def possible_units(), do: @possible_units
def new(value, unit \\ @si_unit) when unit in @possible_units do
%ROT{value: Decimal.cast(value), unit: unit}
end
def to_rad_sec(rot), do: Convertible.convert(rot, :rad_sec)
def to_deg_sec(rot), do: Convertible.convert(rot, :deg_sec)
def to_deg_min(rot), do: Convertible.convert(rot, :deg_min)
def to_ais(rot), do: Convertible.convert(rot, :ais)
defimpl Convertible do
def possible_units(_rot), do: ROT.possible_units
def si_unit(_rot), do: ROT.si_unit()
def si?(rot), do: rot.unit == ROT.si_unit
def to_si(%ROT{value: value, unit: :ais}) do
v = Decimal.div(value, "4.733")
deg_min_si_ratio = ROT.unit_si_ratio[:deg_min]
%ROT{
value: Decimal.mult(v,v) |> Decimal.mult(deg_min_si_ratio),
unit: ROT.si_unit
}
end
def to_si(%ROT{value: value, unit: unit}) do
unit_si_ratio = ROT.unit_si_ratio[unit]
%ROT{
value: Decimal.mult(value, unit_si_ratio),
unit: ROT.si_unit
}
end
def convert(%ROT{unit: unit} = rot, unit), do: rot
def convert(rot, :ais) do
%ROT{value: value} = to_si(rot)
deg_min_si_ratio = ROT.unit_si_ratio[:deg_min]
positive? = Decimal.positive?(value)
value = Decimal.div(value, deg_min_si_ratio)
|> Decimal.abs
|> Decimal.sqrt
|> Decimal.mult("4.733")
value = case positive? do
true -> value
false -> Decimal.mult(-1, value)
end
%ROT{
value: value,
unit: :ais
}
end
def convert(rot, to_unit) do
%ROT{value: value} = to_si(rot)
unit_si_ratio = ROT.unit_si_ratio[to_unit]
%ROT{
value: Decimal.div(value, unit_si_ratio),
unit: to_unit
}
end
end
defimpl String.Chars do
@unit_repr %{rad_sec: "rad/s", deg_sec: "°/s", deg_min: "°/min"}
@unit_precision %{rad_sec: 6, deg_sec: 4, deg_min: 2, ais: 0}
def to_string(%ROT{value: value, unit: :ais} = rot) do
rounded = Decimal.round(value, @unit_precision[:ais]) |> Decimal.to_integer
case rounded do
127 -> ">5°/30s"
-127 -> "<-5°/30s"
128 -> "No turn information"
_ ->
deg_min = rot |> ROT.to_deg_min
"#{deg_min}"
end
end
def to_string(%ROT{value: value, unit: unit}) do
rounded = Decimal.round(value, @unit_precision[unit])
case unit do
:rad_sec -> "#{rounded} #{@unit_repr[unit]}"
_ -> "#{rounded}#{@unit_repr[unit]}"
end
end
end
end
|
lib/ais_front/units/rot.ex
| 0.643217 | 0.681899 |
rot.ex
|
starcoder
|
defmodule Guardian.Plug.Backdoor do
@moduledoc """
This plug allows you to bypass authentication in acceptance tests by passing
the token needed to load the current resource directly to your Guardian module
via a query string parameter.
## Installation
Add the following to your Phoenix router before other Guardian plugs.
```
if Mix.env() == :test do
plug Guardian.Plug.Backdoor, module: MyApp.Guardian
end
plug Guardian.Plug.VerifySession
```
NOTE: This plug is designed for acceptance testing and should never be added
to a production environment.
## Usage
Now that `Guardian.Plug.Backdoor` is installed, it's time to sign in. Pass
your claims as `claims` in the query string of your route.
```
conn = get(conn, "/", claims: %{sub: "User:1"})
resource = MyApp.Guardian.Plug.current_resource(conn)
%{"sub" => "User:1"} = MyApp.Guardian.Plug.current_claims(conn)
```
When the `Guardian.Plug.Backdoor` plug runs, it fetches the resource from your
Guardian implementation with those claims and signs in.
Alternatively, encode your claims into a token and pass that as `token` in the
query string instead.
```
{:ok, token, _claims} = MyApp.Guardian.encode_and_sign(resource)
conn = get(conn, "/", token: token)
resource = MyApp.Guardian.Plug.current_resource(conn)
```
## Options
`:module` - Your app's `Guardian` implementation module. Required.
[hound]: https://github.com/HashNuke/hound
"""
import Plug.Conn
@doc false
def init(opts) do
Enum.into(opts, %{})
end
@doc false
def call(conn, %{module: module}) do
conn = fetch_query_params(conn)
case resource_from_params(module, conn.params) do
{:ok, resource, claims} ->
module = Module.concat(module, Plug)
module.sign_in(conn, resource, claims)
_ ->
conn
end
end
defp resource_from_params(module, %{"token" => token}) do
case module.resource_from_token(token) do
{:ok, resource, claims} -> {:ok, resource, claims}
error -> error
end
end
defp resource_from_params(module, %{"claims" => claims}) do
case module.resource_from_claims(claims) do
{:ok, resource} -> {:ok, resource, claims}
error -> error
end
end
defp resource_from_params(_module, _params), do: :no_resource_found
end
|
lib/guardian/plug/backdoor.ex
| 0.698432 | 0.76769 |
backdoor.ex
|
starcoder
|
defmodule Redix.Protocol do
@moduledoc """
This module provides functions to work with the [Redis binary
protocol](http://redis.io/topics/protocol).
"""
defmodule ParseError do
@moduledoc """
Error in parsing data according to the
[RESP](http://redis.io/topics/protocol) protocol.
"""
defexception [:message]
end
@type redis_value :: binary | integer | nil | Redix.Error.t() | [redis_value]
@type on_parse(value) :: {:ok, value, binary} | {:continuation, (binary -> on_parse(value))}
@crlf "\r\n"
@crlf_iodata [?\r, ?\n]
@doc ~S"""
Packs a list of Elixir terms to a Redis (RESP) array.
This function returns an iodata (instead of a binary) because the packed
result is usually sent to Redis through `:gen_tcp.send/2` or similar. It can
be converted to a binary with `IO.iodata_to_binary/1`.
All elements of `elems` are converted to strings with `to_string/1`, hence
this function supports encoding everything that implements `String.Chars`.
## Examples
iex> iodata = Redix.Protocol.pack(["SET", "mykey", 1])
iex> IO.iodata_to_binary(iodata)
"*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$1\r\n1\r\n"
"""
@spec pack([binary]) :: iodata
def pack(items) when is_list(items) do
pack(items, [], 0)
end
defp pack([item | rest], acc, count) do
item = to_string(item)
new_acc = [acc, [?$, Integer.to_string(byte_size(item)), @crlf_iodata, item, @crlf_iodata]]
pack(rest, new_acc, count + 1)
end
defp pack([], acc, count) do
[?*, Integer.to_string(count), @crlf_iodata, acc]
end
@doc ~S"""
Parses a RESP-encoded value from the given `data`.
Returns `{:ok, value, rest}` if a value is parsed successfully, or a
continuation in the form `{:continuation, fun}` if the data is incomplete.
## Examples
iex> Redix.Protocol.parse("+OK\r\ncruft")
{:ok, "OK", "cruft"}
iex> Redix.Protocol.parse("-ERR wrong type\r\n")
{:ok, %Redix.Error{message: "ERR wrong type"}, ""}
iex> {:continuation, fun} = Redix.Protocol.parse("+OK")
iex> fun.("\r\n")
{:ok, "OK", ""}
"""
@spec parse(binary) :: on_parse(redis_value)
def parse(data)
def parse("+" <> rest), do: parse_simple_string(rest)
def parse("-" <> rest), do: parse_error(rest)
def parse(":" <> rest), do: parse_integer(rest)
def parse("$" <> rest), do: parse_bulk_string(rest)
def parse("*" <> rest), do: parse_array(rest)
def parse(""), do: {:continuation, &parse/1}
def parse(<<byte>> <> _),
do: raise(ParseError, message: "invalid type specifier (#{inspect(<<byte>>)})")
@doc ~S"""
Parses `n` RESP-encoded values from the given `data`.
Each element is parsed as described in `parse/1`. If an element can't be fully
parsed or there are less than `n` elements encoded in `data`, then a
continuation in the form of `{:continuation, fun}` is returned. Otherwise,
`{:ok, values, rest}` is returned. If there's an error in decoding, a
`Redix.Protocol.ParseError` exception is raised.
## Examples
iex> Redix.Protocol.parse_multi("+OK\r\n+COOL\r\n", 2)
{:ok, ["OK", "COOL"], ""}
iex> {:continuation, fun} = Redix.Protocol.parse_multi("+OK\r\n", 2)
iex> fun.("+OK\r\n")
{:ok, ["OK", "OK"], ""}
"""
@spec parse_multi(binary, non_neg_integer) :: on_parse([redis_value])
def parse_multi(data, nelems)
# We treat the case when we have just one element to parse differently as it's
# a very common case since single commands are treated as pipelines with just
# one command in them.
def parse_multi(data, 1) do
resolve_cont(parse(data), &{:ok, [&1], &2})
end
def parse_multi(data, n) do
take_elems(data, n, [])
end
# Type parsers
defp parse_simple_string(data) do
until_crlf(data)
end
defp parse_error(data) do
data
|> until_crlf()
|> resolve_cont(&{:ok, %Redix.Error{message: &1}, &2})
end
defp parse_integer(""), do: {:continuation, &parse_integer/1}
defp parse_integer("-" <> rest),
do: resolve_cont(parse_integer_without_sign(rest), &{:ok, -&1, &2})
defp parse_integer(bin), do: parse_integer_without_sign(bin)
defp parse_integer_without_sign("") do
{:continuation, &parse_integer_without_sign/1}
end
defp parse_integer_without_sign(<<digit, _::binary>> = bin) when digit in ?0..?9 do
resolve_cont(parse_integer_digits(bin, 0), fn i, rest ->
resolve_cont(until_crlf(rest), fn
"", rest ->
{:ok, i, rest}
<<char, _::binary>>, _rest ->
raise ParseError, message: "expected CRLF, found: #{inspect(<<char>>)}"
end)
end)
end
defp parse_integer_without_sign(<<non_digit, _::binary>>) do
raise ParseError, message: "expected integer, found: #{inspect(<<non_digit>>)}"
end
defp parse_integer_digits(<<digit, rest::binary>>, acc) when digit in ?0..?9,
do: parse_integer_digits(rest, acc * 10 + (digit - ?0))
defp parse_integer_digits(<<_non_digit, _::binary>> = rest, acc), do: {:ok, acc, rest}
defp parse_integer_digits(<<>>, acc), do: {:continuation, &parse_integer_digits(&1, acc)}
defp parse_bulk_string(rest) do
resolve_cont(parse_integer(rest), fn
-1, rest ->
{:ok, nil, rest}
size, rest ->
parse_string_of_known_size(rest, size)
end)
end
defp parse_string_of_known_size(data, size) do
case data do
<<str::bytes-size(size), @crlf, rest::binary>> ->
{:ok, str, rest}
_ ->
{:continuation, &parse_string_of_known_size(data <> &1, size)}
end
end
defp parse_array(rest) do
resolve_cont(parse_integer(rest), fn
-1, rest ->
{:ok, nil, rest}
size, rest ->
take_elems(rest, size, [])
end)
end
defp until_crlf(data, acc \\ "")
defp until_crlf(<<@crlf, rest::binary>>, acc), do: {:ok, acc, rest}
defp until_crlf(<<>>, acc), do: {:continuation, &until_crlf(&1, acc)}
defp until_crlf(<<?\r>>, acc), do: {:continuation, &until_crlf(<<?\r, &1::binary>>, acc)}
defp until_crlf(<<byte, rest::binary>>, acc), do: until_crlf(rest, <<acc::binary, byte>>)
defp take_elems(data, 0, acc) do
{:ok, Enum.reverse(acc), data}
end
defp take_elems(<<_, _::binary>> = data, n, acc) when n > 0 do
resolve_cont(parse(data), fn elem, rest ->
take_elems(rest, n - 1, [elem | acc])
end)
end
defp take_elems(<<>>, n, acc) do
{:continuation, &take_elems(&1, n, acc)}
end
defp resolve_cont({:ok, val, rest}, ok) when is_function(ok, 2), do: ok.(val, rest)
defp resolve_cont({:continuation, cont}, ok),
do: {:continuation, fn new_data -> resolve_cont(cont.(new_data), ok) end}
end
|
lib/redix/protocol.ex
| 0.888124 | 0.564639 |
protocol.ex
|
starcoder
|
import Kernel, except: [to_string: 1]
defmodule Macro do
@moduledoc """
Conveniences for working with macros.
"""
@typedoc "Abstract Syntax Tree (AST)"
@type t :: expr | { t, t } | atom | number | binary | pid | fun | [t]
@typedoc "Expr node (remaining ones are literals)"
@type expr :: { expr | atom, Keyword.t, atom | [t] }
@binary_ops [:===, :!==,
:==, :!=, :<=, :>=,
:&&, :||, :<>, :++, :--, :\\, :::, :<-, :.., :|>, :=~,
:<, :>, :->,
:+, :-, :*, :/, :=, :|, :.,
:and, :or, :xor, :when, :in, :inlist, :inbits,
:<<<, :>>>, :|||, :&&&, :^^^, :~~~]
@doc false
defmacro binary_ops, do: @binary_ops
@unary_ops [:!, :@, :^, :not, :+, :-, :~~~, :&]
@doc false
defmacro unary_ops, do: @unary_ops
@spec binary_op_props(atom) :: { :left | :right, precedence :: integer }
defp binary_op_props(o) do
case o do
o when o in [:<-, :inlist, :inbits, :\\, :::] -> {:left, 40}
:| -> {:right, 50}
:when -> {:right, 70}
:= -> {:right, 80}
o when o in [:||, :|||, :or, :xor] -> {:left, 130}
o when o in [:&&, :&&&, :and] -> {:left, 140}
o when o in [:==, :!=, :<, :<=, :>=, :>, :=~, :===, :!==] -> {:left, 150}
o when o in [:|>, :<<<, :>>>] -> {:right, 160}
:in -> {:left, 170}
o when o in [:++, :--, :.., :<>] -> {:right, 200}
o when o in [:+, :-] -> {:left, 210}
o when o in [:*, :/] -> {:left, 220}
:^^^ -> {:left, 250}
:. -> {:left, 310}
end
end
@doc """
Breaks a pipeline expression into a list.
Raises if the pipeline is ill-formed.
"""
@spec unpipe(Macro.t) :: [Macro.t]
def unpipe({ :|> , _, [left, right] }) do
[left|unpipe(right)]
end
def unpipe(other) do
[other]
end
@doc """
Pipes `expr` into the `call_expr` as the
argument in the given `position`.
"""
@spec pipe(Macro.t, Macro.t, integer) :: Macro.t | no_return
def pipe(expr, call_args, integer \\ 0)
def pipe(expr, { :&, _, _ } = call_args, _integer) do
raise ArgumentError, message: "cannot pipe #{to_string expr} into #{to_string call_args}"
end
def pipe(expr, { call, line, atom }, integer) when is_atom(atom) do
{ call, line, List.insert_at([], integer, expr) }
end
def pipe(expr, { call, line, args }, integer) when is_list(args) do
{ call, line, List.insert_at(args, integer, expr) }
end
def pipe(expr, call_args, _integer) do
raise ArgumentError,
message: "cannot pipe #{to_string expr} into #{to_string call_args}"
end
@doc """
Recurs the quoted expression applying the given function to
each metadata node.
This is often useful to remove information like lines and
hygienic counters from the expression for either storage or
comparison.
## Examples
iex> quoted = quote line: 10, do: sample()
{:sample, [line: 10], []}
iex> Macro.update_meta(quoted, &Keyword.delete(&1, :line))
{:sample, [], []}
"""
@spec update_meta(t, (Keyword.t -> Keyword.t)) :: t
def update_meta(quoted, fun)
def update_meta({ left, meta, right }, fun) when is_list(meta) do
{ update_meta(left, fun), fun.(meta), update_meta(right, fun) }
end
def update_meta({ left, right }, fun) do
{ update_meta(left, fun), update_meta(right, fun) }
end
def update_meta(list, fun) when is_list(list) do
for x <- list, do: update_meta(x, fun)
end
def update_meta(other, _fun) do
other
end
@doc """
Decomposes a local or remote call into its remote part (when provided),
function name and argument list.
Returns `:error` when an invalid call syntax is provided.
## Examples
iex> Macro.decompose_call(quote do: foo)
{ :foo, [] }
iex> Macro.decompose_call(quote do: foo())
{ :foo, [] }
iex> Macro.decompose_call(quote do: foo(1, 2, 3))
{ :foo, [1, 2, 3] }
iex> Macro.decompose_call(quote do: Elixir.M.foo(1, 2, 3))
{ { :__aliases__, [], [:Elixir, :M] }, :foo, [1, 2, 3] }
iex> Macro.decompose_call(quote do: 42)
:error
"""
@spec decompose_call(Macro.t) :: { atom, [Macro.t] } | { Macro.t, atom, [Macro.t] } | :error
def decompose_call({ { :., _, [remote, function] }, _, args }) when is_tuple(remote) or is_atom(remote),
do: { remote, function, args }
def decompose_call({ name, _, args }) when is_atom(name) and is_atom(args),
do: { name, [] }
def decompose_call({ name, _, args }) when is_atom(name) and is_list(args),
do: { name, args }
def decompose_call(_),
do: :error
@doc """
Recursively escapes a value so it can be inserted
into a syntax tree.
One may pass `unquote: true` to `escape/2`
which leaves `unquote` statements unescaped, effectively
unquoting the contents on escape.
## Examples
iex> Macro.escape(:foo)
:foo
iex> Macro.escape({ :a, :b, :c })
{ :{}, [], [:a, :b, :c] }
iex> Macro.escape({ :unquote, [], [1] }, unquote: true)
1
"""
@spec escape(term) :: Macro.t
@spec escape(term, Keyword.t) :: Macro.t
def escape(expr, opts \\ []) do
elem(:elixir_quote.escape(expr, Keyword.get(opts, :unquote, false)), 0)
end
@doc ~S"""
Unescape the given chars.
This is the unescaping behaviour used by default in Elixir
single- and double-quoted strings. Check `unescape_string/2`
for information on how to customize the escaping map.
In this setup, Elixir will escape the following: `\a`, `\b`,
`\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Octals are
also escaped according to the latin1 set they represent.
This function is commonly used on sigil implementations
(like `~r`, `~s` and others) which receive a raw, unescaped
string.
## Examples
iex> Macro.unescape_string("example\\n")
"example\n"
In the example above, we pass a string with `\n` escaped
and return a version with it unescaped.
"""
@spec unescape_string(String.t) :: String.t
def unescape_string(chars) do
:elixir_interpolation.unescape_chars(chars)
end
@doc ~S"""
Unescape the given chars according to the map given.
Check `unescape_string/1` if you want to use the same map
as Elixir single- and double-quoted strings.
## Map
The map must be a function. The function receives an integer
representing the codepoint of the character it wants to unescape.
Here is the default mapping function implemented by Elixir:
def unescape_map(?a), do: ?\a
def unescape_map(?b), do: ?\b
def unescape_map(?d), do: ?\d
def unescape_map(?e), do: ?\e
def unescape_map(?f), do: ?\f
def unescape_map(?n), do: ?\n
def unescape_map(?r), do: ?\r
def unescape_map(?s), do: ?\s
def unescape_map(?t), do: ?\t
def unescape_map(?v), do: ?\v
def unescape_map(e), do: e
If the `unescape_map` function returns `false`. The char is
not escaped and `\` is kept in the char list.
## Octals
Octals will by default be escaped unless the map function
returns `false` for `?0`.
## Hex
Hexadecimals will by default be escaped unless the map function
returns `false` for `?x`.
## Examples
Using the `unescape_map` function defined above is easy:
Macro.unescape_string "example\\n", &unescape_map(&1)
"""
@spec unescape_string(String.t, (non_neg_integer -> non_neg_integer | false)) :: String.t
def unescape_string(chars, map) do
:elixir_interpolation.unescape_chars(chars, map)
end
@doc """
Unescape the given tokens according to the default map.
Check `unescape_string/1` and `unescape_string/2` for more
information about unescaping.
Only tokens that are binaries are unescaped, all others are
ignored. This function is useful when implementing your own
sigils. Check the implementation of `Kernel.sigil_s/2`
for examples.
"""
@spec unescape_tokens([Macro.t]) :: [Macro.t]
def unescape_tokens(tokens) do
:elixir_interpolation.unescape_tokens(tokens)
end
@doc """
Unescape the given tokens according to the given map.
Check `unescape_tokens/1` and `unescape_string/2` for more information.
"""
@spec unescape_tokens([Macro.t], (non_neg_integer -> non_neg_integer | false)) :: [Macro.t]
def unescape_tokens(tokens, map) do
:elixir_interpolation.unescape_tokens(tokens, map)
end
@doc """
Converts the given expression to a binary.
## Examples
iex> Macro.to_string(quote do: foo.bar(1, 2, 3))
"foo.bar(1, 2, 3)"
"""
@spec to_string(Macro.t) :: String.t
@spec to_string(Macro.t, (Macro.t, String.t -> String.t)) :: String.t
def to_string(tree, fun \\ fn(_ast, string) -> string end)
# Variables
def to_string({ var, _, atom } = ast, fun) when is_atom(atom) do
fun.(ast, atom_to_binary(var))
end
# Aliases
def to_string({ :__aliases__, _, refs } = ast, fun) do
fun.(ast, Enum.map_join(refs, ".", &call_to_string(&1, fun)))
end
# Blocks
def to_string({ :__block__, _, [expr] } = ast, fun) do
fun.(ast, to_string(expr, fun))
end
def to_string({ :__block__, _, _ } = ast, fun) do
block = adjust_new_lines block_to_string(ast, fun), "\n "
fun.(ast, "(\n " <> block <> "\n)")
end
# Bits containers
def to_string({ :<<>>, _, args } = ast, fun) do
fun.(ast, case Enum.map_join(args, ", ", &to_string(&1, fun)) do
"<" <> rest -> "<< <" <> rest <> " >>"
rest -> "<<" <> rest <> ">>"
end)
end
# Tuple containers
def to_string({ :{}, _, args } = ast, fun) do
tuple = "{" <> Enum.map_join(args, ", ", &to_string(&1, fun)) <> "}"
fun.(ast, tuple)
end
# Map containers
def to_string({ :%{}, _, args } = ast, fun) do
map = "%{" <> map_to_string(args, fun) <> "}"
fun.(ast, map)
end
def to_string({ :%, _, [structname, map] } = ast, fun) do
{ :%{}, _, args } = map
struct = "%" <> to_string(structname, fun) <> "{" <> map_to_string(args, fun) <> "}"
fun.(ast, struct)
end
# Fn keyword
def to_string({ :fn, _, [{ :->, _, [_, tuple] }] = arrow } = ast, fun)
when not is_tuple(tuple) or elem(tuple, 0) != :__block__ do
fun.(ast, "fn " <> arrow_to_string(arrow, fun) <> " end")
end
def to_string({ :fn, _, [{ :->, _, _ }] = block } = ast, fun) do
fun.(ast, "fn " <> block_to_string(block, fun) <> "\nend")
end
def to_string({ :fn, _, block } = ast, fun) do
block = adjust_new_lines block_to_string(block, fun), "\n "
fun.(ast, "fn\n " <> block <> "\nend")
end
# left -> right
def to_string([{ :->, _, _ }|_] = ast, fun) do
fun.(ast, "(" <> arrow_to_string(ast, fun, true) <> ")")
end
# left when right
def to_string({ :when, _, [left, right] } = ast, fun) do
if right != [] and Keyword.keyword?(right) do
right = kw_list_to_string(right, fun)
else
right = fun.(ast, op_to_string(right, fun, :when, :right))
end
fun.(ast, op_to_string(left, fun, :when, :left) <> " when " <> right)
end
# Binary ops
def to_string({ op, _, [left, right] } = ast, fun) when op in unquote(@binary_ops) do
fun.(ast, op_to_string(left, fun, op, :left) <> " #{op} " <> op_to_string(right, fun, op, :right))
end
# Splat when
def to_string({ :when, _, args } = ast, fun) do
{ left, right } = :elixir_utils.split_last(args)
fun.(ast, "(" <> Enum.map_join(left, ", ", &to_string(&1, fun)) <> ") when " <> to_string(right, fun))
end
# Unary ops
def to_string({ unary, _, [{ binary, _, [_, _] } = arg] } = ast, fun)
when unary in unquote(@unary_ops) and binary in unquote(@binary_ops) do
fun.(ast, atom_to_binary(unary) <> "(" <> to_string(arg, fun) <> ")")
end
def to_string({ :not, _, [arg] } = ast, fun) do
fun.(ast, "not " <> to_string(arg, fun))
end
def to_string({ op, _, [arg] } = ast, fun) when op in unquote(@unary_ops) do
fun.(ast, atom_to_binary(op) <> to_string(arg, fun))
end
# Access
def to_string({ { :., _, [Kernel, :access] }, _, [left, right] } = ast, fun) do
fun.(ast, to_string(left, fun) <> to_string(right, fun))
end
# All other calls
def to_string({ target, _, args } = ast, fun) when is_list(args) do
{ list, last } = :elixir_utils.split_last(args)
fun.(ast, case kw_blocks?(last) do
true -> call_to_string_with_args(target, list, fun) <> kw_blocks_to_string(last, fun)
false -> call_to_string_with_args(target, args, fun)
end)
end
# Two-item tuples
def to_string({ left, right }, fun) do
to_string({ :{}, [], [left, right] }, fun)
end
# Lists
def to_string(list, fun) when is_list(list) do
fun.(list, cond do
list == [] ->
"[]"
:io_lib.printable_list(list) ->
"'" <> Inspect.BitString.escape(String.from_char_list!(list), ?') <> "'"
Keyword.keyword?(list) ->
"[" <> kw_list_to_string(list, fun) <> "]"
true ->
"[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]"
end)
end
# All other structures
def to_string(other, fun), do: fun.(other, inspect(other, records: false))
# Block keywords
@kw_keywords [:do, :catch, :rescue, :after, :else]
defp kw_blocks?([_|_] = kw) do
Enum.all?(kw, &match?({x, _} when x in unquote(@kw_keywords), &1))
end
defp kw_blocks?(_), do: false
defp module_to_string(atom, _fun) when is_atom(atom), do: inspect(atom, records: false)
defp module_to_string(other, fun), do: call_to_string(other, fun)
defp call_to_string(atom, _fun) when is_atom(atom), do: atom_to_binary(atom)
defp call_to_string({ :., _, [arg] }, fun), do: module_to_string(arg, fun) <> "."
defp call_to_string({ :., _, [left, right] }, fun), do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
defp call_to_string(other, fun), do: to_string(other, fun)
defp call_to_string_with_args(target, args, fun) do
target = call_to_string(target, fun)
args = args_to_string(args, fun)
target <> "(" <> args <> ")"
end
defp args_to_string(args, fun) do
{ list, last } = :elixir_utils.split_last(args)
if last != [] and Keyword.keyword?(last) do
args = Enum.map_join(list, ", ", &to_string(&1, fun))
if list != [], do: args = args <> ", "
args <> kw_list_to_string(last, fun)
else
Enum.map_join(args, ", ", &to_string(&1, fun))
end
end
defp kw_blocks_to_string(kw, fun) do
Enum.reduce(@kw_keywords, " ", fn(x, acc) ->
case Keyword.has_key?(kw, x) do
true -> acc <> kw_block_to_string(x, Keyword.get(kw, x), fun)
false -> acc
end
end) <> "end"
end
defp kw_block_to_string(key, value, fun) do
block = adjust_new_lines block_to_string(value, fun), "\n "
atom_to_binary(key) <> "\n " <> block <> "\n"
end
defp block_to_string([{ :->, _, _ }|_] = block, fun) do
Enum.map_join(block, "\n", fn({ :->, _, [left, right] }) ->
left = comma_join_or_empty_paren(left, fun, false)
left <> "->\n " <> adjust_new_lines block_to_string(right, fun), "\n "
end)
end
defp block_to_string({ :__block__, _, exprs }, fun) do
Enum.map_join(exprs, "\n", &to_string(&1, fun))
end
defp block_to_string(other, fun), do: to_string(other, fun)
defp map_to_string([{:|, _, [update_map, update_args]}], fun) do
to_string(update_map, fun) <> " | " <> map_to_string(update_args, fun)
end
defp map_to_string(list, fun) do
cond do
Keyword.keyword?(list) -> kw_list_to_string(list, fun)
true -> map_list_to_string(list, fun)
end
end
defp kw_list_to_string(list, fun) do
Enum.map_join(list, ", ", fn { key, value } ->
atom_to_binary(key) <> ": " <> to_string(value, fun)
end)
end
defp map_list_to_string(list, fun) do
Enum.map_join(list, ", ", fn { key, value } ->
to_string(key, fun) <> " => " <> to_string(value, fun)
end)
end
defp parenthise(expr, fun) do
"(" <> to_string(expr, fun) <> ")"
end
defp op_to_string({ op, _, [_, _] } = expr, fun, parent_op, side) when op in unquote(@binary_ops) do
{ parent_assoc, parent_prec } = binary_op_props(parent_op)
{ _, prec } = binary_op_props(op)
cond do
parent_prec < prec -> to_string(expr, fun)
parent_prec > prec -> parenthise(expr, fun)
true ->
# parent_prec == prec, so look at associativity.
if parent_assoc == side do
to_string(expr, fun)
else
parenthise(expr, fun)
end
end
end
defp op_to_string(expr, fun, _, _), do: to_string(expr, fun)
defp arrow_to_string(pairs, fun, paren \\ false) do
Enum.map_join(pairs, "; ", fn({ :->, _, [left, right] }) ->
left = comma_join_or_empty_paren(left, fun, paren)
left <> "-> " <> to_string(right, fun)
end)
end
defp comma_join_or_empty_paren([], _fun, true), do: "() "
defp comma_join_or_empty_paren([], _fun, false), do: ""
defp comma_join_or_empty_paren(left, fun, _) do
Enum.map_join(left, ", ", &to_string(&1, fun)) <> " "
end
defp adjust_new_lines(block, replacement) do
for <<x <- block>>, into: "" do
case x == ?\n do
true -> replacement
false -> <<x>>
end
end
end
@doc """
Receives an AST node and expands it once.
The following contents are expanded:
* Macros (local or remote);
* Aliases are expanded (if possible) and return atoms;
* Pseudo-variables (`__ENV__`, `__MODULE__` and `__DIR__`);
* Module attributes reader (`@foo`);
If the expression cannot be expanded, it returns the expression
itself. Notice that `expand_once/2` performs the expansion just
once and it is not recursive. Check `expand/2` for expansion
until the node can no longer be expanded.
## Examples
In the example below, we have a macro that generates a module
with a function named `name_length` that returns the length
of the module name. The value of this function will be calculated
at compilation time and not at runtime.
Consider the implementation below:
defmacro defmodule_with_length(name, do: block) do
length = length(atom_to_list(name))
quote do
defmodule unquote(name) do
def name_length, do: unquote(length)
unquote(block)
end
end
end
When invoked like this:
defmodule_with_length My.Module do
def other_function, do: ...
end
The compilation will fail because `My.Module` when quoted
is not an atom, but a syntax tree as follow:
{:__aliases__, [], [:My, :Module] }
That said, we need to expand the aliases node above to an
atom, so we can retrieve its length. Expanding the node is
not straight-forward because we also need to expand the
caller aliases. For example:
alias MyHelpers, as: My
defmodule_with_length My.Module do
def other_function, do: ...
end
The final module name will be `MyHelpers.Module` and not
`My.Module`. With `Macro.expand/2`, such aliases are taken
into consideration. Local and remote macros are also
expanded. We could rewrite our macro above to use this
function as:
defmacro defmodule_with_length(name, do: block) do
expanded = Macro.expand(name, __CALLER__)
length = length(atom_to_list(expanded))
quote do
defmodule unquote(name) do
def name_length, do: unquote(length)
unquote(block)
end
end
end
"""
def expand_once(ast, env) do
elem(do_expand_once(ast, env), 0)
end
defp do_expand_once({ :__aliases__, _, _ } = original, env) do
case :elixir_aliases.expand(original, env.aliases, env.macro_aliases, env.lexical_tracker) do
receiver when is_atom(receiver) ->
:elixir_lexical.record_remote(receiver, env.lexical_tracker)
{ receiver, true }
aliases ->
aliases = for alias <- aliases, do: elem(do_expand_once(alias, env), 0)
case :lists.all(&is_atom/1, aliases) do
true ->
receiver = :elixir_aliases.concat(aliases)
:elixir_lexical.record_remote(receiver, env.lexical_tracker)
{ receiver, true }
false ->
{ original, false }
end
end
end
# Expand @ calls
defp do_expand_once({ :@, _, [{ name, _, args }] } = original, env) when is_atom(args) or args == [] do
case (module = env.module) && Module.open?(module) do
true -> { Module.get_attribute(module, name), true }
false -> { original, false }
end
end
# Expand pseudo-variables
defp do_expand_once({ :__MODULE__, _, atom }, env) when is_atom(atom),
do: { env.module, true }
defp do_expand_once({ :__DIR__, _, atom }, env) when is_atom(atom),
do: { :filename.dirname(env.file), true }
defp do_expand_once({ :__ENV__, _, atom }, env) when is_atom(atom),
do: { { :{}, [], tuple_to_list(env) }, true }
defp do_expand_once({ { :., _, [{ :__ENV__, _, atom }, field] }, _, [] } = original, env) when
is_atom(atom) and is_atom(field) do
case :erlang.function_exported(Macro.Env, field, 1) do
true -> { apply(env, field, []), true }
false -> { original, false }
end
end
# Expand possible macro import invocation
defp do_expand_once({ atom, meta, context } = original, env)
when is_atom(atom) and is_list(meta) and is_atom(context) do
if :lists.member({ atom, Keyword.get(meta, :counter, context) }, env.vars) do
{ original, false }
else
case do_expand_once({ atom, meta, [] }, env) do
{ _, true } = exp -> exp
{ _, false } -> { original, false }
end
end
end
defp do_expand_once({ atom, meta, args } = original, env)
when is_atom(atom) and is_list(args) and is_list(meta) do
arity = length(args)
if :elixir_import.special_form(atom, arity) do
{ original, false }
else
module = env.module
extra = if function_exported?(module, :__info__, 1) do
[{ module, module.__info__(:macros) }]
else
[]
end
expand = :elixir_dispatch.expand_import(meta, { atom, length(args) }, args,
:elixir_env.ex_to_env(env), extra)
case expand do
{ :ok, receiver, quoted } ->
next = :elixir_counter.next
{ :elixir_quote.linify_with_context_counter(0, { receiver, next }, quoted), true }
{ :ok, _receiver } ->
{ original, false }
:error ->
{ original, false }
end
end
end
# Expand possible macro require invocation
defp do_expand_once({ { :., _, [left, right] }, meta, args } = original, env) when is_atom(right) do
{ receiver, _ } = do_expand_once(left, env)
case is_atom(receiver) do
false -> { original, false }
true ->
expand = :elixir_dispatch.expand_require(meta, receiver, { right, length(args) },
args, :elixir_env.ex_to_env(env))
case expand do
{ :ok, receiver, quoted } ->
next = :elixir_counter.next
{ :elixir_quote.linify_with_context_counter(0, { receiver, next }, quoted), true }
:error ->
{ original, false }
end
end
end
# Anything else is just returned
defp do_expand_once(other, _env), do: { other, false }
@doc """
Receives an AST node and expands it until it can no longer
be expanded.
This function uses `expand_once/2` under the hood. Check
`expand_once/2` for more information and exmaples.
"""
def expand(tree, env) do
expand_until({ tree, true }, env)
end
defp expand_until({ tree, true }, env) do
expand_until(do_expand_once(tree, env), env)
end
defp expand_until({ tree, false }, _env) do
tree
end
@doc """
Recursively traverses the quoted expression checking if all sub-terms are
safe.
Terms are considered safe if they represent data structures and don't actually
evaluate code. Returns `:ok` unless a given term is unsafe,
which is returned as `{ :unsafe, term }`.
"""
def safe_term(terms) do
do_safe_term(terms) || :ok
end
defp do_safe_term({ local, _, terms }) when local in [:{}, :%{}, :__aliases__] do
do_safe_term(terms)
end
defp do_safe_term({ unary, _, [term] }) when unary in [:+, :-] do
do_safe_term(term)
end
defp do_safe_term({ left, right }), do: do_safe_term(left) || do_safe_term(right)
defp do_safe_term(terms) when is_list(terms), do: Enum.find_value(terms, &do_safe_term(&1))
defp do_safe_term(terms) when is_tuple(terms), do: { :unsafe, terms }
defp do_safe_term(_), do: nil
end
|
lib/elixir/lib/macro.ex
| 0.7413 | 0.538923 |
macro.ex
|
starcoder
|
defmodule Extatus.Metric.Histogram do
@moduledoc """
This module defines a wrapper over `Prometheus.Metric.Histogram` functions to
be compatible with `Extatus` way of handling metrics.
"""
alias Extatus.Settings
@metric Settings.extatus_histogram_mod()
@doc """
Creates a histogram using the `name` of a metric.
"""
defmacro new(name) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).get_spec(name) do
{unquote(module), spec} ->
unquote(metric).new(spec)
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Creates a histogram using the `name` of a `metric`. If the counter exists,
returns false.
"""
defmacro declare(name) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).get_spec(name) do
{unquote(module), spec} ->
unquote(metric).declare(spec)
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Observes the given `amount` for the histogram identified by `name` and
`values` (keyword list with the correspondence between labels and values).
"""
defmacro observe(name, values, amount \\ 1) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).observe(spec, unquote(amount))
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Observes the given `amount` for the histogram identified by `name` and
`values` (keyword list with the correspondence between labels and values). If
`amount` happened to be a float number even one time(!) you shoudn't use
`observe/3` after `dobserve/3`.
"""
defmacro dobserve(name, values, amount \\ 1) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).dobserve(spec, unquote(amount))
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Observes the histogram identified by `name` and `values` (keyword list with
the correspondence between labels and values) to the amount of time spent
executing `function`.
"""
defmacro observe_duration(name, values, function) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).observe_duration(spec, unquote(function))
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Removes histogram series identified by `name` and `values` (keyword list with
the correspondence between labels and values).
"""
defmacro remove(name, values) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).remove(spec)
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Resets the value of the histogram identified by `name` and `values`
(keyword list with the correspondence between labels and values).
"""
defmacro reset(name, values) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).reset(spec)
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
@doc """
Returns the value of the histogram identified by `name` and `values`
(keyword list with the correspondence between labels and values).
"""
defmacro value(name, values) do
module = __MODULE__
caller = __CALLER__.module()
metric = @metric
quote do
require Prometheus.Metric.Histogram
name = unquote(name)
case unquote(caller).gen_spec(name, unquote(values)) do
{unquote(module), spec} ->
unquote(metric).value(spec)
_ ->
raise %Prometheus.UnknownMetricError{registry: nil, name: name}
end
end
end
end
|
lib/extatus/metric/histogram.ex
| 0.896 | 0.655164 |
histogram.ex
|
starcoder
|
defmodule Snitch.Data.Model.Promotion.Applicability do
@moduledoc """
Exposes functions related to promotion level checks.
"""
use Snitch.Data.Model
alias Snitch.Data.Schema.Promotion
@errors %{
not_found: "promotion not found",
inactive: "promotion is not active",
expired: "promotion has expired"
}
@success %{
promo_active: "promotion active",
has_actions: "has actions"
}
@doc """
Checks if a valid coupon exists for the supplied coupon_code.
The function along with valid `code` name also checks if coupon is not
`archived`.
"""
@spec valid_coupon_check(String.t()) :: {:ok, Promotion.t()} | {:error, String.t()}
def valid_coupon_check(coupon_code) do
case Repo.get_by(Promotion, code: coupon_code, archived_at: 0) do
nil ->
{:error, @errors.not_found}
promotion ->
{:ok, promotion}
end
end
def promotion_active(promotion) do
if promotion.active? do
{true, @success.promo_active}
else
{false, @errors.inactive}
end
end
def promotion_actions_exist(promotion) do
promotion = Repo.preload(promotion, :actions)
case promotion.actions do
[] ->
{false, @errors.inactive}
_ ->
{true, @success.has_actions}
end
end
@doc """
Checks for `starts_at` date for promotion.
If the `starts_at` is in past then `true` is returned otherwise, if `starts_at`
is in future it means promotion has not started and not active is returned
for the promotion.
"""
def starts_at_check(promotion) do
if DateTime.compare(DateTime.utc_now(), promotion.starts_at) == :gt do
{true, @success.promo_active}
else
{false, @errors.inactive}
end
end
@doc """
Checks for `expires_at` date for the promotion.
If `expires_at` is in past then the coupon has expired otherwise it is
still active.
"""
def expires_at_check(promotion) do
if DateTime.compare(DateTime.utc_now(), promotion.expires_at) == :lt do
{true, @success.promo_active}
else
{false, @errors.expired}
end
end
@doc """
Checks for `usage_limit` for the promotion.
If usage limit reached returns {false, message} and coupon code expired
otherwise returns {true, message}.
### Note
In case the `usage_limit` property of promotion has been set to zero,
it is being assumed that the store keeper wants the usage limit to be infinite.
"""
def usage_limit_check(promotion) do
if promotion.usage_limit == 0 do
{true, @success.promo_active}
else
if promotion.usage_limit > promotion.current_usage_count do
{true, @success.promo_active}
else
{false, @errors.expired}
end
end
end
end
|
apps/snitch_core/lib/core/data/model/promotion/promotion_applicability.ex
| 0.828106 | 0.414247 |
promotion_applicability.ex
|
starcoder
|
defmodule Vow.Pat do
@moduledoc """
This module provides a vow for wrapping a pattern and the `Vow.Pat.pat/1`
macro for conveniently wrapping the pattern and packaging it in `Vow.Pat.t`.
# Note
Installation of the `Expat` package is recommended if using this module as
`Expat` provides excellent utilities for defining and reusing patterns.
```
def deps do
[{:expat, "~> 1.0"}]
end
```
"""
use Vow.Utils.AccessShortcut,
type: :passthrough,
passthrough_key: :pat
import Kernel, except: [match?: 2]
defstruct [:pat]
@type t :: %__MODULE__{
pat: Macro.t()
}
@doc false
@spec new(Macro.t()) :: t | no_return
def new(pattern) do
%__MODULE__{pat: pattern}
end
@doc """
Wraps a pattern and stores it in `Vow.Pat.t` for later matching.
## Examples
```
iex> import Vow.Pat
...> p = pat({:ok, _})
...> Vow.conform(p, {:ok, :foo})
{:ok, {:ok, :foo}}
```
"""
@spec pat(Macro.t()) :: Macro.t()
defmacro pat(pat) do
quote do
Vow.Pat.new(unquote(Macro.escape(Macro.expand(pat, __ENV__))))
end
end
@doc """
A convenience function that checks if the right side (an expresssion),
matches the left side (a `Vow.Pat`).
"""
@spec match?(t, expr :: term) :: boolean | no_return
def match?(%__MODULE__{pat: pat}, expr) do
{result, _bindings} =
Code.eval_quoted(
quote do
Kernel.match?(unquote(pat), unquote(expr))
end
)
result
end
defimpl Vow.Conformable do
@moduledoc false
import Vow.FunctionWrapper, only: [wrap: 2]
alias Vow.ConformError
@impl Vow.Conformable
def conform(vow, path, via, route, val) do
if @for.match?(vow, val) do
{:ok, val}
else
pred = wrap(&@for.match?(vow, &1), vow: vow)
{:error, [ConformError.new_problem(pred, path, via, route, val)]}
end
rescue
error ->
msg = Exception.message(error)
{:error, [ConformError.new_problem(vow, path, via, route, val, msg)]}
end
@impl Vow.Conformable
def unform(_vow, val) do
{:ok, val}
end
@impl Vow.Conformable
def regex?(_vow), do: false
end
defimpl Inspect do
@moduledoc false
@impl Inspect
def inspect(%@for{pat: pat}, _opts) do
Macro.to_string(pat)
end
end
if Code.ensure_loaded?(StreamData) do
defimpl Vow.Generatable do
@moduledoc false
alias Vow.Utils
import StreamData
@impl Vow.Generatable
def gen(vow, opts) do
ignore_warn? = Keyword.get(opts, :ignore_warn?, false)
_ = Utils.no_override_warn(vow, ignore_warn?)
{:ok, filter(term(), &@for.match?(vow, &1))}
end
end
end
end
|
lib/vow/pat.ex
| 0.905706 | 0.835953 |
pat.ex
|
starcoder
|
defmodule AtomTweaks.Tweaks.Tweak do
@moduledoc """
Represents a tweak.
## Fields
* `code` - Source code of the tweak
* `description` - Markdown description of what the tweak does
* `title` - Title of the tweak
* `type` - The type of the tweak
### Associations
Must be preloaded before they can be used.
* `forked_from` - The `AtomTweaks.Tweaks.Tweak` this tweak was forked from
* `forks` - The `AtomTweaks.Tweaks.Tweak` records that have been forked from this tweak
* `stargazers` - The `AtomTweaks.Accounts.User` records that have starred this tweak
* `user` - The `AtomTweaks.Accounts.User` that created or forked this tweak
"""
use Ecto.Schema
import Ecto.Changeset
import Ecto.Query
alias Ecto.Changeset
alias AtomTweaks.Accounts.User
alias AtomTweaks.Ecto.Markdown
alias AtomTweaks.Tweaks.Star
alias AtomTweaks.Tweaks.Tweak
alias AtomTweaksWeb.PageMetadata.Metadata
@type t :: %__MODULE__{}
@changeset_keys ~w{code created_by description parent title type}a
@primary_key {:id, :binary_id, autogenerate: true}
schema "tweaks" do
field(:code, :string)
field(:description, Markdown)
field(:title, :string)
field(:type, :string)
belongs_to(:forked_from, Tweak, foreign_key: :parent, type: :binary_id)
belongs_to(:user, User, foreign_key: :created_by, type: :binary_id)
has_many(:forks, Tweak, foreign_key: :parent)
many_to_many(
:stargazers,
User,
join_through: Star,
on_replace: :delete,
on_delete: :delete_all
)
timestamps()
end
@doc false
def changeset(struct, params \\ %{}) do
struct
|> cast(params, @changeset_keys)
|> validate_required([:title, :code, :created_by, :type])
|> validate_inclusion(:type, ["init", "style"])
end
@doc """
Filters `query` to include only tweaks of `type`.
If `nil` is given for the type, the query is not filtered. This allows for easily building the
query in a pipeline.
"""
def filter_by_type(query, nil), do: query
def filter_by_type(query, type), do: from(t in query, where: t.type == ^type)
@doc """
Filters `query` to include only tweaks that were created by `user`.
If `nil` is given for the user, the query is not filtered. This allows for easily building the
query in a pipeline.
"""
def filter_by_user(query, nil), do: query
def filter_by_user(query, user = %User{}), do: from(t in query, where: t.created_by == ^user.id)
def fork_params(tweak, user) do
tweak
|> copy_params(@changeset_keys)
|> Map.merge(%{created_by: user.id, parent: tweak.id})
end
def include_forks(query, true), do: query
def include_forks(query, _), do: from(t in query, where: is_nil(t.parent))
@doc """
Validates that the person forking the tweak is different from the original author of the tweak.
"""
@spec validate_fork_by_different_user(Changeset.t(), t() | binary) :: Changeset.t()
def validate_fork_by_different_user(changeset, original_tweak)
def validate_fork_by_different_user(changeset, %Tweak{created_by: created_by}) do
validate_fork_by_different_user(changeset, created_by)
end
def validate_fork_by_different_user(changeset, original_id) when is_binary(original_id) do
validate_change(changeset, :created_by, fn _field, creator_id ->
if creator_id == original_id do
[{:created_by, "cannot fork your own tweak"}]
else
[]
end
end)
end
defimpl Metadata do
def to_metadata(tweak) do
[
[property: "og:title", content: tweak.title],
[property: "og:description", content: tweak.code]
]
end
end
# Copy only `keys` out of `map` into a new map
defp copy_params(map, keys) do
Enum.reduce(keys, %{}, fn key, acc -> Map.put(acc, key, Map.fetch!(map, key)) end)
end
end
|
lib/atom_tweaks/tweaks/tweak.ex
| 0.79854 | 0.514095 |
tweak.ex
|
starcoder
|
defmodule ExStoneOpenbank.TeslaHelper do
@moduledoc """
Group of functions that helps in the utilization of Mox in Tesla Adapters
"""
import Mox
import Tesla.Mock, only: [json: 2]
import ExUnit.Assertions
alias ExStoneOpenbank.TeslaMock
defmodule RequestMatchError do
defexception [:message]
def exception(request: request) do
message = """
A Tesla mock request could not be matched in an `expect_call`.
This usually happens when the fun head can't match on an incoming request. Please,
check if URL, method and other request data can match the expectation.
Incoming request: #{inspect(request)}
"""
%__MODULE__{message: message}
end
end
@doc "Helper for expecting a Tesla call"
@spec expect_call(n :: integer(), call_fun :: (Tesla.Env.t() -> {:ok | :error, Tesla.Env.t()})) ::
term()
def expect_call(n \\ 1, call_fun) do
unless Function.info(call_fun, :arity) == {:arity, 1} do
raise "expect_call must receive a function with arity 1"
end
TeslaMock
|> expect(:call, n, fn request, _opts ->
try do
call_fun.(request)
rescue
FunctionClauseError ->
reraise RequestMatchError, [request: request], __STACKTRACE__
end
end)
end
@doc "Helper for building a JSON Tesla.Env response"
@spec json_response(body :: map() | String.t() | integer() | boolean(), status :: pos_integer()) ::
{:ok, Tesla.Env.t()}
def json_response(body, status \\ 200) do
{:ok, json(body, status: status)}
end
@doc "Expects an authenticate call"
@spec expect_authentication(client_id :: String.t(), {:ok, Tesla.Env.t()}) :: term()
def expect_authentication(client_id, response \\ nil) do
expect_call(1, fn
%{headers: [{"content-type", "application/x-www-form-urlencoded"}]} = env ->
assert_authentication(client_id, response, env)
end)
end
def assert_authentication(client_id, response, env) do
assert env.body =~ "client_id=#{client_id}"
assert env.body =~ "grant_type=client_credentials"
assert env.body =~
"client_assertion_type=#{
URI.encode_www_form("urn:ietf:params:oauth:client-assertion-type:jwt-bearer")
}"
if response,
do: response,
else: json_response(%{access_token: "token"})
end
end
|
test/support/tesla_helper.ex
| 0.736401 | 0.438785 |
tesla_helper.ex
|
starcoder
|
defmodule BowlingGame do
defstruct scores: List.duplicate([0, 0], 12),
current_frame: 1,
roll_in_frame: 1
end
defmodule Bowling do
def start do
%BowlingGame{}
end
def roll(_, score) when score < 0 do
{:error, "Negative roll is invalid"}
end
def roll(_, score) when score > 10 do
{:error, "Pin count exceeds pins on the lane"}
end
def roll(game, score) do
updates = update_score(game.roll_in_frame, game, score)
cond do
too_many_frames?(updates) ->
{:error, "Cannot roll after game is over"}
valid_updates?(updates) ->
{:ok, updates}
true ->
{:error, "Pin count exceeds pins on the lane"}
end
end
defp update_score(1, game, score) do
current_frame = game.current_frame
scores = List.replace_at(game.scores, current_frame - 1, [score, 0])
cond do
score == 10 ->
%{game | current_frame: current_frame + 1, scores: scores}
true ->
%{game | roll_in_frame: 2, scores: scores}
end
end
defp update_score(2, game, score) do
current_frame = game.current_frame
old_scores = game.scores
old_frame_values = Enum.at(old_scores, current_frame - 1)
new_frame_values = List.replace_at(old_frame_values, 1, score)
new_scores = List.replace_at(old_scores, current_frame - 1, new_frame_values)
%{game | scores: new_scores, roll_in_frame: 1, current_frame: current_frame + 1}
end
defp valid_updates?(updates) do
Enum.all?(updates.scores, fn frame -> Enum.sum(frame) <= 10 end)
end
def score(game) do
cond do
game.current_frame < 10 ->
{:error, "Score cannot be taken until the end of the game"}
bonus_roll_remaining?(game) ->
{:error, "Score cannot be taken until the end of the game"}
true ->
{:ok, parse_scores(game.scores)}
end
end
defp bonus_roll_remaining?(game) do
final_frame = Enum.at(game.scores, 9)
cond do
strike?(final_frame) ->
cond do
strike?(Enum.at(game.scores, 10)) ->
game.current_frame == 12 && game.roll_in_frame == 1
true ->
game.current_frame < 12
end
spare?(final_frame) ->
game.current_frame == 11 && game.roll_in_frame == 1
true ->
false
end
end
defp too_many_frames?(game) do
final_frame = Enum.at(game.scores, 9)
bonus_frame_1 = Enum.at(game.scores, 10)
bonus_frame_2 = Enum.at(game.scores, 11)
cond do
# If last frame is all strikes:
strike?(final_frame) && strike?(bonus_frame_1) && strike?(bonus_frame_2) ->
game.current_frame == 13 && game.roll_in_frame == 2
# If last frame has two strikes:
strike?(final_frame) && strike?(bonus_frame_1) && not strike?(bonus_frame_2) ->
game.current_frame == 13 && game.roll_in_frame == 1
# If last frame has one strike and some other combination
strike?(final_frame) && not strike?(bonus_frame_1) ->
game.current_frame == 12 && game.roll_in_frame == 2
# If last frame has a spare, and one strike
spare?(final_frame) && strike?(bonus_frame_1) ->
game.current_frame == 12 && game.roll_in_frame == 2
# If last frame has a spare and some other combination
spare?(final_frame) && not strike?(bonus_frame_1) ->
game.current_frame == 12 && game.roll_in_frame == 1
# All of the others
true ->
game.current_frame == 11 && game.roll_in_frame == 2
end
end
defp parse_scores(scores) do
scores
|> score_frames
|> Enum.sum()
end
defp score_frames(scores) do
Enum.map(0..9, fn idx ->
current_frame = Enum.at(scores, idx)
next_frame = Enum.at(scores, idx + 1, [0, 0])
cond do
strike?(current_frame) ->
strike(current_frame, next_frame, scores, idx)
spare?(current_frame) ->
10 + hd(next_frame)
true ->
Enum.sum(current_frame)
end
end)
end
defp strike?(frame) do
frame == [10, 0]
end
defp strike(current_frame, next_frame, scores, idx) do
if strike?(next_frame) do
Enum.sum(current_frame) + Enum.sum(next_frame) +
(Enum.at(scores, idx + 2, [0, 0]) |> Enum.at(0))
else
Enum.sum(Enum.at(scores, idx)) + Enum.sum(Enum.at(scores, idx + 1, [0, 0]))
end
end
defp spare?(frame) do
Enum.sum(frame) == 10
end
end
|
exercises/practice/bowling/.meta/example.ex
| 0.695131 | 0.610424 |
example.ex
|
starcoder
|
defmodule ExWire.Message do
@moduledoc """
Defines a behavior for messages so that they can be
easily encoded and decoded.
"""
defmodule UnknownMessageError do
defexception [:message]
end
@type t ::
ExWire.Message.Ping.t()
| ExWire.Message.Pong.t()
| ExWire.Message.FindNeighbours.t()
| ExWire.Message.Neighbours.t()
@type handlers ::
ExWire.Message.Ping
| ExWire.Message.Pong
| ExWire.Message.FindNeighbours
| ExWire.Message.Neighbours
@type message_id :: integer()
@callback message_id() :: message_id
@callback encode(t) :: binary()
@callback to(t) :: ExWire.Endpoint.t() | nil
@message_types %{
0x01 => ExWire.Message.Ping,
0x02 => ExWire.Message.Pong,
0x03 => ExWire.Message.FindNeighbours,
0x04 => ExWire.Message.Neighbours
}
@doc """
Decodes a message of given `type` based on the encoded
data. Effectively reverses the `decode/1` function.
## Examples
iex> ExWire.Message.decode(0x01, <<210, 1, 199, 132, 1, 2, 3, 4, 128, 5, 199, 132, 5, 6, 7, 8, 6, 128, 4>>)
%ExWire.Message.Ping{
version: 1,
from: %ExWire.Struct.Endpoint{ip: {1, 2, 3, 4}, tcp_port: 5, udp_port: nil},
to: %ExWire.Struct.Endpoint{ip: {5, 6, 7, 8}, tcp_port: nil, udp_port: 6},
timestamp: 4
}
iex> ExWire.Message.decode(0x02, <<202, 199, 132, 5, 6, 7, 8, 6, 128, 2, 3>>)
%ExWire.Message.Pong{
to: %ExWire.Struct.Endpoint{ip: {5, 6, 7, 8}, tcp_port: nil, udp_port: 6}, hash: <<2>>, timestamp: 3
}
iex> ExWire.Message.decode(0x99, <<>>)
** (ExWire.Message.UnknownMessageError) Unknown message type: 0x99
"""
@spec decode(integer(), binary()) :: t
def decode(type, data) do
case @message_types[type] do
nil -> raise UnknownMessageError, "Unknown message type: #{inspect(type, base: :hex)}"
mod -> mod.decode(data)
end
end
@doc """
Encoded a message by concatting its `message_id` to
the encoded data of the message itself.
## Examples
iex> ExWire.Message.encode(
...> %ExWire.Message.Ping{
...> version: 1,
...> from: %ExWire.Struct.Endpoint{ip: {1, 2, 3, 4}, tcp_port: 5, udp_port: nil},
...> to: %ExWire.Struct.Endpoint{ip: {5, 6, 7, 8}, tcp_port: nil, udp_port: 6},
...> timestamp: 4
...> }
...> )
<<1, 214, 1, 201, 132, 1, 2, 3, 4, 128, 130, 0, 5, 201, 132, 5, 6, 7, 8, 130, 0, 6, 128, 4>>
iex> ExWire.Message.encode(%ExWire.Message.Pong{to: %ExWire.Struct.Endpoint{ip: {5, 6, 7, 8}, tcp_port: nil, udp_port: 6}, hash: <<2>>, timestamp: 3})
<<2, 204, 201, 132, 5, 6, 7, 8, 130, 0, 6, 128, 2, 3>>
"""
@spec encode(t) :: binary()
def encode(message) do
<<message.__struct__.message_id()>> <> message.__struct__.encode(message)
end
end
|
apps/ex_wire/lib/ex_wire/message.ex
| 0.860838 | 0.408247 |
message.ex
|
starcoder
|
defmodule Membrane.Element.Base do
@moduledoc """
Module defining behaviour common to all elements.
When used declares behaviour implementation, provides default callback definitions
and imports macros.
# Elements
Elements are units that produce, process or consume data. They can be linked
with `Membrane.Pipeline`, and thus form a pipeline able to perform complex data
processing. Each element defines a set of pads, through which it can be linked
with other elements. During playback, pads can either send (output pads) or
receive (input pads) data. For more information on pads, see
`Membrane.Pad`.
To implement an element, one of base modules (`Membrane.Source`,
`Membrane.Filter`, `Membrane.Sink`)
has to be `use`d, depending on the element type:
- source, producing buffers (contain only output pads),
- filter, processing buffers (contain both input and output pads),
- sink, consuming buffers (contain only input pads).
For more information on each element type, check documentation for appropriate
base module.
## Behaviours
Element-specific behaviours are specified in modules:
- `Membrane.Element.Base` - this module, behaviour common to all
elements,
- `Membrane.Element.WithOutputPads` - behaviour common to sources
and filters,
- `Membrane.Element.WithInputPads` - behaviour common to sinks and
filters,
- Base modules (`Membrane.Source`, `Membrane.Filter`,
`Membrane.Sink`) - behaviours specific to each element type.
## Callbacks
Modules listed above provide specifications of callbacks that define elements
lifecycle. All of these callbacks have names with the `handle_` prefix.
They are used to define reaction to certain events that happen during runtime,
and indicate what actions framework should undertake as a result, besides
executing element-specific code.
For actions that can be returned by each callback, see `Membrane.Element.Action`
module.
"""
use Bunch
alias Membrane.{Element, Event, Pad}
alias Membrane.Core.OptionsSpecs
alias Membrane.Element.{Action, CallbackContext}
@typedoc """
Type that defines all valid return values from most callbacks.
In case of error, a callback is supposed to return `{:error, any}` if it is not
passed state, and `{{:error, any}, state}` otherwise.
"""
@type callback_return_t ::
{:ok | {:ok, [Action.t()]} | {:error, any}, Element.state_t()} | {:error, any}
@doc """
Automatically implemented callback returning specification of pads exported
by the element.
Generated by `Membrane.Element.WithInputPads.def_input_pad/2`
and `Membrane..WithOutputPads.def_output_pad/2` macros.
"""
@callback membrane_pads() :: [{Pad.name_t(), Pad.description_t()}]
@doc """
Automatically implemented callback used to determine if module is a membrane element.
"""
@callback membrane_element? :: true
@doc """
Automatically implemented callback used to determine whether element exports clock.
"""
@callback membrane_clock? :: true
@doc """
Automatically implemented callback determining whether element is a source,
a filter or a sink.
"""
@callback membrane_element_type :: Element.type_t()
@doc """
Callback invoked on initialization of element process. It should parse options
and initialize element internal state. Internally it is invoked inside
`c:GenServer.init/1` callback.
"""
@callback handle_init(options :: Element.options_t()) ::
{:ok, Element.state_t()}
| {:error, any}
@doc """
Callback invoked when element goes to `:prepared` state from state `:stopped` and should get
ready to enter `:playing` state.
Usually most resources used by the element are allocated here.
For example, if element opens a file, this is the place to try to actually open it
and return error if that has failed. Such resources should be released in `c:handle_prepared_to_stopped/2`.
"""
@callback handle_stopped_to_prepared(
context :: CallbackContext.PlaybackChange.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked when element goes to `:prepared` state from state `:playing` and should get
ready to enter `:stopped` state.
All resources allocated in `c:handle_prepared_to_playing/2` callback should be released here, and no more buffers or
demands should be sent.
"""
@callback handle_playing_to_prepared(
context :: CallbackContext.PlaybackChange.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked when element is supposed to start playing (goes from state `:prepared` to `:playing`).
This is moment when initial demands are sent and first buffers are generated
if there are any pads in the push mode.
"""
@callback handle_prepared_to_playing(
context :: CallbackContext.PlaybackChange.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked when element is supposed to stop (goes from state `:prepared` to `:stopped`).
Usually this is the place for releasing all remaining resources
used by the element. For example, if element opens a file in `c:handle_stopped_to_prepared/2`,
this is the place to close it.
"""
@callback handle_prepared_to_stopped(
context :: CallbackContext.PlaybackChange.t(),
state :: Element.state_t()
) :: callback_return_t
@callback handle_stopped_to_terminating(
context :: CallbackContext.PlaybackChange.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked when element receives a message that is not recognized
as an internal membrane message.
Useful for receiving ticks from timer, data sent from NIFs or other stuff.
"""
@callback handle_other(
message :: any(),
context :: CallbackContext.Other.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback that is called when new pad has beed added to element. Executed
ONLY for dynamic pads.
"""
@callback handle_pad_added(
pad :: Pad.ref_t(),
context :: CallbackContext.PadAdded.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback that is called when some pad of the element has beed removed. Executed
ONLY for dynamic pads.
"""
@callback handle_pad_removed(
pad :: Pad.ref_t(),
context :: CallbackContext.PadRemoved.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback that is called when event arrives.
Events may arrive from both sinks and sources. In filters by default event is
forwarded to all sources or sinks, respectively.
"""
@callback handle_event(
pad :: Pad.ref_t(),
event :: Event.t(),
context :: CallbackContext.Event.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked upon each timer tick. A timer can be started with `Membrane.Element.Action.start_timer_t`
action.
"""
@callback handle_tick(
timer_id :: any,
context :: CallbackContext.Tick.t(),
state :: Element.state_t()
) :: callback_return_t
@doc """
Callback invoked when element is shutting down just before process is exiting.
Internally called in `c:GenServer.terminate/2` callback.
"""
@callback handle_shutdown(reason, state :: Element.state_t()) :: :ok
when reason: :normal | :shutdown | {:shutdown, any} | term()
@optional_callbacks membrane_clock?: 0,
handle_init: 1,
handle_stopped_to_prepared: 2,
handle_prepared_to_playing: 2,
handle_playing_to_prepared: 2,
handle_prepared_to_stopped: 2,
handle_other: 3,
handle_pad_added: 3,
handle_pad_removed: 3,
handle_event: 4,
handle_tick: 3,
handle_shutdown: 2
@doc """
Macro defining options that parametrize element.
It automatically generates appropriate struct and documentation.
#{OptionsSpecs.options_doc()}
"""
defmacro def_options(options) do
OptionsSpecs.def_options(__CALLER__.module, options, :element)
end
@doc """
Defines that element exports a clock to pipeline.
Exporting clock allows pipeline to choose it as the pipeline clock, enabling other
elements to synchronize with it. Element's clock is accessible via `clock` field,
while pipeline's one - via `parent_clock` field in callback contexts. Both of
them can be used for starting timers.
"""
defmacro def_clock(doc \\ "") do
quote do
@membrane_element_has_clock true
Module.put_attribute(__MODULE__, :membrane_clock_moduledoc, """
## Clock
This element provides a clock to its parent.
#{unquote(doc)}
""")
@impl true
def membrane_clock?, do: true
end
end
@doc false
defmacro __before_compile__(env) do
Membrane.Core.Child.generate_moduledoc(env.module, :element)
end
@doc """
Brings common stuff needed to implement an element. Used by
`Membrane.Source.__using__/1`, `Membrane.Filter.__using__/1`
and `Membrane.Sink.__using__/1`.
Options:
- `:bring_pad?` - if true (default) requires and aliases `Membrane.Pad`
"""
defmacro __using__(options) do
bring_pad =
if options |> Keyword.get(:bring_pad?, true) do
quote do
require Membrane.Pad
alias Membrane.Pad
end
end
quote location: :keep do
@behaviour unquote(__MODULE__)
@before_compile unquote(__MODULE__)
alias Membrane.Element.CallbackContext, as: Ctx
import unquote(__MODULE__), only: [def_clock: 0, def_clock: 1, def_options: 1]
unquote(bring_pad)
@impl true
def membrane_element?, do: true
@impl true
def handle_init(%opt_struct{} = options), do: {:ok, options |> Map.from_struct()}
def handle_init(options), do: {:ok, options}
@impl true
def handle_stopped_to_prepared(_context, state), do: {:ok, state}
@impl true
def handle_prepared_to_playing(_context, state), do: {:ok, state}
@impl true
def handle_playing_to_prepared(_context, state), do: {:ok, state}
@impl true
def handle_prepared_to_stopped(_context, state), do: {:ok, state}
@impl true
def handle_stopped_to_terminating(_context, state), do: {:ok, state}
@impl true
def handle_other(_message, _context, state), do: {:ok, state}
@impl true
def handle_pad_added(_pad, _context, state), do: {:ok, state}
@impl true
def handle_pad_removed(_pad, _context, state), do: {:ok, state}
@impl true
def handle_event(_pad, _event, _context, state), do: {:ok, state}
@impl true
def handle_shutdown(_reason, _state), do: :ok
defoverridable handle_init: 1,
handle_stopped_to_prepared: 2,
handle_playing_to_prepared: 2,
handle_prepared_to_playing: 2,
handle_prepared_to_stopped: 2,
handle_other: 3,
handle_pad_added: 3,
handle_pad_removed: 3,
handle_event: 4,
handle_shutdown: 2
end
end
end
|
lib/membrane/element/base.ex
| 0.922787 | 0.653182 |
base.ex
|
starcoder
|
defmodule ExDoc.Markdown do
@moduledoc """
Transform a given document in Markdown to HTML
ExDoc supports the following Markdown parsers:
* [Hoedown][]
* [Earmark][]
* [Cmark][]
If you don't specify a parser in `config/config.exs`, ExDoc will try to
find one of the Markdown parsers from the list above in top-down fashion.
Otherwise, ExDoc will raise an exception.
[Hoedown]: https://github.com/hoedown/hoedown
[Earmark]: http://github.com/pragdave/earmark
[Cmark]: https://github.com/asaaki/cmark.ex
"""
@markdown_processors [
ExDoc.Markdown.Hoedown,
ExDoc.Markdown.Earmark,
ExDoc.Markdown.Cmark
]
@markdown_processor_key :markdown_processor
@doc """
Converts the given markdown document to HTML.
"""
def to_html(text, opts \\ []) when is_binary(text) do
pretty_codeblocks(get_markdown_processor().to_html(text, opts))
end
@doc """
Helper to handle plain code blocks (```...```) with and without
language specification and indentation code blocks
"""
def pretty_codeblocks(bin) do
bin = Regex.replace(~r/<pre><code(\s+class=\"\")?>\s*iex>/,
# Add "elixir" class for now, until we have support for
# "iex" in highlight.js
bin, ~S(<pre><code class="iex elixir">iex>))
bin = Regex.replace(~r/<pre><code(\s+class=\"\")?>/,
bin, ~S(<pre><code class="elixir">))
bin
end
defp get_markdown_processor do
case Application.fetch_env(:ex_doc, @markdown_processor_key) do
{:ok, processor} ->
processor
:error ->
processor = find_markdown_processor() || raise_no_markdown_processor()
Application.put_env(:ex_doc, @markdown_processor_key, processor)
processor
end
end
defp find_markdown_processor do
Enum.find @markdown_processors, fn module ->
Code.ensure_loaded?(module) && module.available?
end
end
defp raise_no_markdown_processor do
raise """
Could not find a markdown processor to be used by ex_doc.
You can either:
* Add {:earmark, ">= 0.0.0"} to your mix.exs deps
to use an Elixir-based markdown processor
* Add {:markdown, github: "devinus/markdown"} to your mix.exs deps
to use a C-based markdown processor
* Add {:cmark, ">= 0.5"} to your mix.exs deps
to use another C-based markdown processor
"""
end
end
|
lib/ex_doc/markdown.ex
| 0.765856 | 0.662669 |
markdown.ex
|
starcoder
|
defmodule HL7.Composite.Default.XCN do
@moduledoc """
2.9.52 XCN - extended composite ID number and name for persons
Components:
- `id_number` (ST)
- `family_name` (FN)
- `given_name` (ST)
- `second_name` (ST)
- `suffix` (ST)
- `prefix` (ST)
- `degree` (IS)
- `source_table` (IS)
- `assigning_authority` (HD)
- `name_type_code` (ID)
- `check_digit` (ST)
- `check_digit_scheme` (ID)
- `id_type` (IS)
- `assigning_facility` (HD)
- `name_representation_code` (ID)
- `name_context` (CE)
- `name_validity` (DR)
- `name_assembly_order` (ID)
Subcomponents of `family_name`:
- `surname` (ST)
- `own_surname_prefix` (ST)
- `own_surname` (ST)
- `surname_prefix_from_partner` (ST)
- `surname_from_partner` (ST)
Subcomponents of `assigning_authority`:
- `namespace_id` (IS)
- `universal_id` (ST)
- `universal_id_type` (ID)
Subcomponents of `assigning_facility`:
- `namespace_id` (IS)
- `universal_id` (ST)
- `universal_id_type` (ID)
Subcomponents of `name_context`:
- `id` (ST)
- `text` (ST)
- `coding_system` (IS)
- `alt_id` (ST)
- `alt_text` (ST)
- `alt_coding_system` (IS)
Subcomponents of `name_validity`:
- `start_datetime` (TS)
- `end_datetime` (TS)
This data type is used extensively appearing in the PV1, ORC, RXO, RXE, OBR
and SCH segments, as well as others, where there is a need to specify the
ID number and name of a person.
## Examples
Neither an assigning authority nor an assigning facility are present in the
example:
|1234567^Smith^John^J^III^DR^PHD^ADT01^^L^4^M11^MR|
"""
use HL7.Composite.Spec
require HL7.Composite.Default.CE, as: CE
require HL7.Composite.Default.DR, as: DR
require HL7.Composite.Default.HD, as: HD
composite do
component :id_number, type: :string
component :family_name, type: :string
component :given_name, type: :string
component :second_name, type: :string
component :suffix, type: :string
component :prefix, type: :string
component :degree, type: :string
component :source_table, type: :string
component :assigning_authority, type: HD
component :name_type_code, type: :string
component :check_digit, type: :string
component :check_digit_scheme, type: :string
component :id_type, type: :string
component :assigning_facility, type: HD
component :name_representation_code, type: :string
component :name_context, type: CE
component :name_validity, type: DR
component :name_assembly_order, type: :string
component :effective_date, type: :datetime
component :expiration_date, type: :datetime
component :professional_suffix, type: :string
end
end
|
lib/ex_hl7/composite/default/xcn.ex
| 0.800458 | 0.619788 |
xcn.ex
|
starcoder
|
defmodule AWS.SSM do
@moduledoc """
Amazon Web Services Systems Manager is a collection of capabilities that helps
you automate management tasks such as collecting system inventory, applying
operating system (OS) patches, automating the creation of Amazon Machine Images
(AMIs), and configuring operating systems (OSs) and applications at scale.
Systems Manager lets you remotely and securely manage the configuration of your
managed nodes. A *managed node* is any Amazon Elastic Compute Cloud (Amazon EC2)
instance, edge device, or on-premises server or virtual machine (VM) that has
been configured for Systems Manager.
With support for IoT Greengrass Version 2 devices, the phrase *managed instance*
has been changed to *managed node* in most of the Systems Manager documentation.
The Systems Manager console, API calls, error messages, and SSM documents still
use the term instance.
This reference is intended to be used with the [Amazon Web Services Systems Manager User
Guide](https://docs.aws.amazon.com/systems-manager/latest/userguide/).
To get started, verify prerequisites and configure managed nodes. For more
information, see [Setting up Amazon Web Services Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-setting-up.html)
in the *Amazon Web Services Systems Manager User Guide*.
## Related resources
* For information about how to use a Query API, see [Making API requests](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/making-api-requests.html).
* For information about other API operations you can perform on EC2
instances, see the [Amazon EC2 API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/).
* For information about AppConfig, a capability of Systems Manager,
see the [AppConfig User Guide](https://docs.aws.amazon.com/appconfig/latest/userguide/) and the
[AppConfig API Reference](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/).
* For information about Incident Manager, a capability of Systems
Manager, see the [Incident Manager User Guide](https://docs.aws.amazon.com/incident-manager/latest/userguide/) and the
[Incident Manager API Reference](https://docs.aws.amazon.com/incident-manager/latest/APIReference/).
"""
alias AWS.Client
alias AWS.Request
def metadata do
%AWS.ServiceMetadata{
abbreviation: "Amazon SSM",
api_version: "2014-11-06",
content_type: "application/x-amz-json-1.1",
credential_scope: nil,
endpoint_prefix: "ssm",
global?: false,
protocol: "json",
service_id: "SSM",
signature_version: "v4",
signing_name: "ssm",
target_prefix: "AmazonSSM"
}
end
@doc """
Adds or overwrites one or more tags for the specified resource.
Tags are metadata that you can assign to your documents, managed nodes,
maintenance windows, Parameter Store parameters, and patch baselines. Tags
enable you to categorize your resources in different ways, for example, by
purpose, owner, or environment. Each tag consists of a key and an optional
value, both of which you define. For example, you could define a set of tags for
your account's managed nodes that helps you track each node's owner and stack
level. For example:
* `Key=Owner,Value=DbAdmin`
* `Key=Owner,Value=SysAdmin`
* `Key=Owner,Value=Dev`
* `Key=Stack,Value=Production`
* `Key=Stack,Value=Pre-Production`
* `Key=Stack,Value=Test`
Each resource can have a maximum of 50 tags.
We recommend that you devise a set of tag keys that meets your needs for each
resource type. Using a consistent set of tag keys makes it easier for you to
manage your resources. You can search and filter the resources based on the tags
you add. Tags don't have any semantic meaning to and are interpreted strictly as
a string of characters.
For more information about using tags with Amazon Elastic Compute Cloud (Amazon
EC2) instances, see [Tagging your Amazon EC2 resources](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
in the *Amazon EC2 User Guide*.
"""
def add_tags_to_resource(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "AddTagsToResource", input, options)
end
@doc """
Associates a related item to a Systems Manager OpsCenter OpsItem.
For example, you can associate an Incident Manager incident or analysis with an
OpsItem. Incident Manager and OpsCenter are capabilities of Amazon Web Services
Systems Manager.
"""
def associate_ops_item_related_item(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "AssociateOpsItemRelatedItem", input, options)
end
@doc """
Attempts to cancel the command specified by the Command ID.
There is no guarantee that the command will be terminated and the underlying
process stopped.
"""
def cancel_command(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CancelCommand", input, options)
end
@doc """
Stops a maintenance window execution that is already in progress and cancels any
tasks in the window that haven't already starting running.
Tasks already in progress will continue to completion.
"""
def cancel_maintenance_window_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CancelMaintenanceWindowExecution", input, options)
end
@doc """
Generates an activation code and activation ID you can use to register your
on-premises servers, edge devices, or virtual machine (VM) with Amazon Web
Services Systems Manager.
Registering these machines with Systems Manager makes it possible to manage them
using Systems Manager capabilities. You use the activation code and ID when
installing SSM Agent on machines in your hybrid environment. For more
information about requirements for managing on-premises machines using Systems
Manager, see [Setting up Amazon Web Services Systems Manager for hybrid environments](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html)
in the *Amazon Web Services Systems Manager User Guide*.
Amazon Elastic Compute Cloud (Amazon EC2) instances, edge devices, and
on-premises servers and VMs that are configured for Systems Manager are all
called *managed nodes*.
"""
def create_activation(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateActivation", input, options)
end
@doc """
A State Manager association defines the state that you want to maintain on your
managed nodes.
For example, an association can specify that anti-virus software must be
installed and running on your managed nodes, or that certain ports must be
closed. For static targets, the association specifies a schedule for when the
configuration is reapplied. For dynamic targets, such as an Amazon Web Services
resource group or an Amazon Web Services autoscaling group, State Manager, a
capability of Amazon Web Services Systems Manager applies the configuration when
new managed nodes are added to the group. The association also specifies actions
to take when applying the configuration. For example, an association for
anti-virus software might run once a day. If the software isn't installed, then
State Manager installs it. If the software is installed, but the service isn't
running, then the association might instruct State Manager to start the service.
"""
def create_association(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateAssociation", input, options)
end
@doc """
Associates the specified Amazon Web Services Systems Manager document (SSM
document) with the specified managed nodes or targets.
When you associate a document with one or more managed nodes using IDs or tags,
Amazon Web Services Systems Manager Agent (SSM Agent) running on the managed
node processes the document and configures the node as specified.
If you associate a document with a managed node that already has an associated
document, the system returns the AssociationAlreadyExists exception.
"""
def create_association_batch(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateAssociationBatch", input, options)
end
@doc """
Creates a Amazon Web Services Systems Manager (SSM document).
An SSM document defines the actions that Systems Manager performs on your
managed nodes. For more information about SSM documents, including information
about supported schemas, features, and syntax, see [Amazon Web Services Systems Manager
Documents](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def create_document(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateDocument", input, options)
end
@doc """
Creates a new maintenance window.
The value you specify for `Duration` determines the specific end time for the
maintenance window based on the time it begins. No maintenance window tasks are
permitted to start after the resulting endtime minus the number of hours you
specify for `Cutoff`. For example, if the maintenance window starts at 3 PM, the
duration is three hours, and the value you specify for `Cutoff` is one hour, no
maintenance window tasks can start after 5 PM.
"""
def create_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateMaintenanceWindow", input, options)
end
@doc """
Creates a new OpsItem.
You must have permission in Identity and Access Management (IAM) to create a new
OpsItem. For more information, see [Getting started with OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html)
in the *Amazon Web Services Systems Manager User Guide*.
Operations engineers and IT professionals use Amazon Web Services Systems
Manager OpsCenter to view, investigate, and remediate operational issues
impacting the performance and health of their Amazon Web Services resources. For
more information, see [Amazon Web Services Systems Manager OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def create_ops_item(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateOpsItem", input, options)
end
@doc """
If you create a new application in Application Manager, Amazon Web Services
Systems Manager calls this API operation to specify information about the new
application, including the application type.
"""
def create_ops_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateOpsMetadata", input, options)
end
@doc """
Creates a patch baseline.
For information about valid key-value pairs in `PatchFilters` for each supported
operating system type, see `PatchFilter`.
"""
def create_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreatePatchBaseline", input, options)
end
@doc """
A resource data sync helps you view data from multiple sources in a single
location.
Amazon Web Services Systems Manager offers two types of resource data sync:
`SyncToDestination` and `SyncFromSource`.
You can configure Systems Manager Inventory to use the `SyncToDestination` type
to synchronize Inventory data from multiple Amazon Web Services Regions to a
single Amazon Simple Storage Service (Amazon S3) bucket. For more information,
see [Configuring resource data sync for Inventory](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-datasync.html)
in the *Amazon Web Services Systems Manager User Guide*.
You can configure Systems Manager Explorer to use the `SyncFromSource` type to
synchronize operational work items (OpsItems) and operational data (OpsData)
from multiple Amazon Web Services Regions to a single Amazon S3 bucket. This
type can synchronize OpsItems and OpsData from multiple Amazon Web Services
accounts and Amazon Web Services Regions or `EntireOrganization` by using
Organizations. For more information, see [Setting up Systems Manager Explorer to display data from multiple accounts and
Regions](https://docs.aws.amazon.com/systems-manager/latest/userguide/Explorer-resource-data-sync.html)
in the *Amazon Web Services Systems Manager User Guide*.
A resource data sync is an asynchronous operation that returns immediately.
After a successful initial sync is completed, the system continuously syncs
data. To check the status of a sync, use the `ListResourceDataSync`.
By default, data isn't encrypted in Amazon S3. We strongly recommend that you
enable encryption in Amazon S3 to ensure secure data storage. We also recommend
that you secure access to the Amazon S3 bucket by creating a restrictive bucket
policy.
"""
def create_resource_data_sync(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "CreateResourceDataSync", input, options)
end
@doc """
Deletes an activation.
You aren't required to delete an activation. If you delete an activation, you
can no longer use it to register additional managed nodes. Deleting an
activation doesn't de-register managed nodes. You must manually de-register
managed nodes.
"""
def delete_activation(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteActivation", input, options)
end
@doc """
Disassociates the specified Amazon Web Services Systems Manager document (SSM
document) from the specified managed node.
If you created the association by using the `Targets` parameter, then you must
delete the association by using the association ID.
When you disassociate a document from a managed node, it doesn't change the
configuration of the node. To change the configuration state of a managed node
after you disassociate a document, you must create a new document with the
desired configuration and associate it with the node.
"""
def delete_association(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteAssociation", input, options)
end
@doc """
Deletes the Amazon Web Services Systems Manager document (SSM document) and all
managed node associations to the document.
Before you delete the document, we recommend that you use `DeleteAssociation` to
disassociate all managed nodes that are associated with the document.
"""
def delete_document(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteDocument", input, options)
end
@doc """
Delete a custom inventory type or the data associated with a custom Inventory
type.
Deleting a custom inventory type is also referred to as deleting a custom
inventory schema.
"""
def delete_inventory(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteInventory", input, options)
end
@doc """
Deletes a maintenance window.
"""
def delete_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteMaintenanceWindow", input, options)
end
@doc """
Delete OpsMetadata related to an application.
"""
def delete_ops_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteOpsMetadata", input, options)
end
@doc """
Delete a parameter from the system.
After deleting a parameter, wait for at least 30 seconds to create a parameter
with the same name.
"""
def delete_parameter(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteParameter", input, options)
end
@doc """
Delete a list of parameters.
After deleting a parameter, wait for at least 30 seconds to create a parameter
with the same name.
"""
def delete_parameters(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteParameters", input, options)
end
@doc """
Deletes a patch baseline.
"""
def delete_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeletePatchBaseline", input, options)
end
@doc """
Deletes a resource data sync configuration.
After the configuration is deleted, changes to data on managed nodes are no
longer synced to or from the target. Deleting a sync configuration doesn't
delete data.
"""
def delete_resource_data_sync(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeleteResourceDataSync", input, options)
end
@doc """
Removes the server or virtual machine from the list of registered servers.
You can reregister the node again at any time. If you don't plan to use Run
Command on the server, we suggest uninstalling SSM Agent first.
"""
def deregister_managed_instance(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DeregisterManagedInstance", input, options)
end
@doc """
Removes a patch group from a patch baseline.
"""
def deregister_patch_baseline_for_patch_group(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DeregisterPatchBaselineForPatchGroup",
input,
options
)
end
@doc """
Removes a target from a maintenance window.
"""
def deregister_target_from_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DeregisterTargetFromMaintenanceWindow",
input,
options
)
end
@doc """
Removes a task from a maintenance window.
"""
def deregister_task_from_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DeregisterTaskFromMaintenanceWindow",
input,
options
)
end
@doc """
Describes details about the activation, such as the date and time the activation
was created, its expiration date, the Identity and Access Management (IAM) role
assigned to the managed nodes in the activation, and the number of nodes
registered by using this activation.
"""
def describe_activations(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeActivations", input, options)
end
@doc """
Describes the association for the specified target or managed node.
If you created the association by using the `Targets` parameter, then you must
retrieve the association by using the association ID.
"""
def describe_association(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeAssociation", input, options)
end
@doc """
Views information about a specific execution of a specific association.
"""
def describe_association_execution_targets(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeAssociationExecutionTargets",
input,
options
)
end
@doc """
Views all executions for a specific association ID.
"""
def describe_association_executions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeAssociationExecutions", input, options)
end
@doc """
Provides details about all active and terminated Automation executions.
"""
def describe_automation_executions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeAutomationExecutions", input, options)
end
@doc """
Information about all active and terminated step executions in an Automation
workflow.
"""
def describe_automation_step_executions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeAutomationStepExecutions", input, options)
end
@doc """
Lists all patches eligible to be included in a patch baseline.
"""
def describe_available_patches(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeAvailablePatches", input, options)
end
@doc """
Describes the specified Amazon Web Services Systems Manager document (SSM
document).
"""
def describe_document(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeDocument", input, options)
end
@doc """
Describes the permissions for a Amazon Web Services Systems Manager document
(SSM document).
If you created the document, you are the owner. If a document is shared, it can
either be shared privately (by specifying a user's Amazon Web Services account
ID) or publicly (*All*).
"""
def describe_document_permission(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeDocumentPermission", input, options)
end
@doc """
All associations for the managed node(s).
"""
def describe_effective_instance_associations(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeEffectiveInstanceAssociations",
input,
options
)
end
@doc """
Retrieves the current effective patches (the patch and the approval state) for
the specified patch baseline.
Applies to patch baselines for Windows only.
"""
def describe_effective_patches_for_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeEffectivePatchesForPatchBaseline",
input,
options
)
end
@doc """
The status of the associations for the managed node(s).
"""
def describe_instance_associations_status(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeInstanceAssociationsStatus", input, options)
end
@doc """
Describes one or more of your managed nodes, including information about the
operating system platform, the version of SSM Agent installed on the managed
node, node status, and so on.
If you specify one or more managed node IDs, it returns information for those
managed nodes. If you don't specify node IDs, it returns information for all
your managed nodes. If you specify a node ID that isn't valid or a node that you
don't own, you receive an error.
The `IamRole` field for this API operation is the Identity and Access Management
(IAM) role assigned to on-premises managed nodes. This call doesn't return the
IAM role for EC2 instances.
"""
def describe_instance_information(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeInstanceInformation", input, options)
end
@doc """
Retrieves the high-level patch state of one or more managed nodes.
"""
def describe_instance_patch_states(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeInstancePatchStates", input, options)
end
@doc """
Retrieves the high-level patch state for the managed nodes in the specified
patch group.
"""
def describe_instance_patch_states_for_patch_group(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeInstancePatchStatesForPatchGroup",
input,
options
)
end
@doc """
Retrieves information about the patches on the specified managed node and their
state relative to the patch baseline being used for the node.
"""
def describe_instance_patches(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeInstancePatches", input, options)
end
@doc """
Describes a specific delete inventory operation.
"""
def describe_inventory_deletions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeInventoryDeletions", input, options)
end
@doc """
Retrieves the individual task executions (one per target) for a particular task
run as part of a maintenance window execution.
"""
def describe_maintenance_window_execution_task_invocations(
%Client{} = client,
input,
options \\ []
) do
Request.request_post(
client,
metadata(),
"DescribeMaintenanceWindowExecutionTaskInvocations",
input,
options
)
end
@doc """
For a given maintenance window execution, lists the tasks that were run.
"""
def describe_maintenance_window_execution_tasks(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeMaintenanceWindowExecutionTasks",
input,
options
)
end
@doc """
Lists the executions of a maintenance window.
This includes information about when the maintenance window was scheduled to be
active, and information about tasks registered and run with the maintenance
window.
"""
def describe_maintenance_window_executions(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeMaintenanceWindowExecutions",
input,
options
)
end
@doc """
Retrieves information about upcoming executions of a maintenance window.
"""
def describe_maintenance_window_schedule(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeMaintenanceWindowSchedule", input, options)
end
@doc """
Lists the targets registered with the maintenance window.
"""
def describe_maintenance_window_targets(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeMaintenanceWindowTargets", input, options)
end
@doc """
Lists the tasks in a maintenance window.
For maintenance window tasks without a specified target, you can't supply values
for `--max-errors` and `--max-concurrency`. Instead, the system inserts a
placeholder value of `1`, which may be reported in the response to this command.
These values don't affect the running of your task and can be ignored.
"""
def describe_maintenance_window_tasks(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeMaintenanceWindowTasks", input, options)
end
@doc """
Retrieves the maintenance windows in an Amazon Web Services account.
"""
def describe_maintenance_windows(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeMaintenanceWindows", input, options)
end
@doc """
Retrieves information about the maintenance window targets or tasks that a
managed node is associated with.
"""
def describe_maintenance_windows_for_target(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"DescribeMaintenanceWindowsForTarget",
input,
options
)
end
@doc """
Query a set of OpsItems.
You must have permission in Identity and Access Management (IAM) to query a list
of OpsItems. For more information, see [Getting started with OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html)
in the *Amazon Web Services Systems Manager User Guide*.
Operations engineers and IT professionals use Amazon Web Services Systems
Manager OpsCenter to view, investigate, and remediate operational issues
impacting the performance and health of their Amazon Web Services resources. For
more information, see
[OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def describe_ops_items(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeOpsItems", input, options)
end
@doc """
Get information about a parameter.
Request results are returned on a best-effort basis. If you specify `MaxResults`
in the request, the response includes information up to the limit specified. The
number of items returned, however, can be between zero and the value of
`MaxResults`. If the service reaches an internal limit while processing the
results, it stops the operation and returns the matching values up to that point
and a `NextToken`. You can specify the `NextToken` in a subsequent call to get
the next set of results.
If you change the KMS key alias for the KMS key used to encrypt a parameter,
then you must also update the key alias the parameter uses to reference KMS.
Otherwise, `DescribeParameters` retrieves whatever the original key alias was
referencing.
"""
def describe_parameters(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeParameters", input, options)
end
@doc """
Lists the patch baselines in your Amazon Web Services account.
"""
def describe_patch_baselines(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribePatchBaselines", input, options)
end
@doc """
Returns high-level aggregated patch compliance state information for a patch
group.
"""
def describe_patch_group_state(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribePatchGroupState", input, options)
end
@doc """
Lists all patch groups that have been registered with patch baselines.
"""
def describe_patch_groups(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribePatchGroups", input, options)
end
@doc """
Lists the properties of available patches organized by product, product family,
classification, severity, and other properties of available patches.
You can use the reported properties in the filters you specify in requests for
operations such as `CreatePatchBaseline`, `UpdatePatchBaseline`,
`DescribeAvailablePatches`, and `DescribePatchBaselines`.
The following section lists the properties that can be used in filters for each
major operating system type:
## Definitions
### AMAZON_LINUX
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### AMAZON_LINUX_2
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### CENTOS
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### DEBIAN
Valid properties: `PRODUCT` | `PRIORITY`
### MACOS
Valid properties: `PRODUCT` | `CLASSIFICATION`
### ORACLE_LINUX
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### REDHAT_ENTERPRISE_LINUX
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### SUSE
Valid properties: `PRODUCT` | `CLASSIFICATION` | `SEVERITY`
### UBUNTU
Valid properties: `PRODUCT` | `PRIORITY`
### WINDOWS
Valid properties: `PRODUCT` | `PRODUCT_FAMILY` | `CLASSIFICATION` |
`MSRC_SEVERITY`
"""
def describe_patch_properties(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribePatchProperties", input, options)
end
@doc """
Retrieves a list of all active sessions (both connected and disconnected) or
terminated sessions from the past 30 days.
"""
def describe_sessions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DescribeSessions", input, options)
end
@doc """
Deletes the association between an OpsItem and a related item.
For example, this API operation can delete an Incident Manager incident from an
OpsItem. Incident Manager is a capability of Amazon Web Services Systems
Manager.
"""
def disassociate_ops_item_related_item(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "DisassociateOpsItemRelatedItem", input, options)
end
@doc """
Get detailed information about a particular Automation execution.
"""
def get_automation_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetAutomationExecution", input, options)
end
@doc """
Gets the state of a Amazon Web Services Systems Manager change calendar at the
current time or a specified time.
If you specify a time, `GetCalendarState` returns the state of the calendar at
that specific time, and returns the next time that the change calendar state
will transition. If you don't specify a time, `GetCalendarState` uses the
current time. Change Calendar entries have two possible states: `OPEN` or
`CLOSED`.
If you specify more than one calendar in a request, the command returns the
status of `OPEN` only if all calendars in the request are open. If one or more
calendars in the request are closed, the status returned is `CLOSED`.
For more information about Change Calendar, a capability of Amazon Web Services
Systems Manager, see [Amazon Web Services Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def get_calendar_state(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetCalendarState", input, options)
end
@doc """
Returns detailed information about command execution for an invocation or
plugin.
`GetCommandInvocation` only gives the execution status of a plugin in a
document. To get the command execution status on a specific managed node, use
`ListCommandInvocations`. To get the command execution status across managed
nodes, use `ListCommands`.
"""
def get_command_invocation(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetCommandInvocation", input, options)
end
@doc """
Retrieves the Session Manager connection status for a managed node to determine
whether it is running and ready to receive Session Manager connections.
"""
def get_connection_status(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetConnectionStatus", input, options)
end
@doc """
Retrieves the default patch baseline.
Amazon Web Services Systems Manager supports creating multiple default patch
baselines. For example, you can create a default patch baseline for each
operating system.
If you don't specify an operating system value, the default patch baseline for
Windows is returned.
"""
def get_default_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetDefaultPatchBaseline", input, options)
end
@doc """
Retrieves the current snapshot for the patch baseline the managed node uses.
This API is primarily used by the `AWS-RunPatchBaseline` Systems Manager
document (SSM document).
If you run the command locally, such as with the Command Line Interface (CLI),
the system attempts to use your local Amazon Web Services credentials and the
operation fails. To avoid this, you can run the command in the Amazon Web
Services Systems Manager console. Use Run Command, a capability of Amazon Web
Services Systems Manager, with an SSM document that enables you to target a
managed node with a script or command. For example, run the command using the
`AWS-RunShellScript` document or the `AWS-RunPowerShellScript` document.
"""
def get_deployable_patch_snapshot_for_instance(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"GetDeployablePatchSnapshotForInstance",
input,
options
)
end
@doc """
Gets the contents of the specified Amazon Web Services Systems Manager document
(SSM document).
"""
def get_document(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetDocument", input, options)
end
@doc """
Query inventory information.
This includes managed node status, such as `Stopped` or `Terminated`.
"""
def get_inventory(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetInventory", input, options)
end
@doc """
Return a list of inventory type names for the account, or return a list of
attribute names for a specific Inventory item type.
"""
def get_inventory_schema(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetInventorySchema", input, options)
end
@doc """
Retrieves a maintenance window.
"""
def get_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetMaintenanceWindow", input, options)
end
@doc """
Retrieves details about a specific a maintenance window execution.
"""
def get_maintenance_window_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetMaintenanceWindowExecution", input, options)
end
@doc """
Retrieves the details about a specific task run as part of a maintenance window
execution.
"""
def get_maintenance_window_execution_task(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetMaintenanceWindowExecutionTask", input, options)
end
@doc """
Retrieves information about a specific task running on a specific target.
"""
def get_maintenance_window_execution_task_invocation(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"GetMaintenanceWindowExecutionTaskInvocation",
input,
options
)
end
@doc """
Lists the tasks in a maintenance window.
For maintenance window tasks without a specified target, you can't supply values
for `--max-errors` and `--max-concurrency`. Instead, the system inserts a
placeholder value of `1`, which may be reported in the response to this command.
These values don't affect the running of your task and can be ignored.
"""
def get_maintenance_window_task(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetMaintenanceWindowTask", input, options)
end
@doc """
Get information about an OpsItem by using the ID.
You must have permission in Identity and Access Management (IAM) to view
information about an OpsItem. For more information, see [Getting started with OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html)
in the *Amazon Web Services Systems Manager User Guide*.
Operations engineers and IT professionals use Amazon Web Services Systems
Manager OpsCenter to view, investigate, and remediate operational issues
impacting the performance and health of their Amazon Web Services resources. For
more information, see
[OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def get_ops_item(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetOpsItem", input, options)
end
@doc """
View operational metadata related to an application in Application Manager.
"""
def get_ops_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetOpsMetadata", input, options)
end
@doc """
View a summary of operations metadata (OpsData) based on specified filters and
aggregators.
OpsData can include information about Amazon Web Services Systems Manager
OpsCenter operational workitems (OpsItems) as well as information about any
Amazon Web Services resource or service configured to report OpsData to Amazon
Web Services Systems Manager Explorer.
"""
def get_ops_summary(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetOpsSummary", input, options)
end
@doc """
Get information about a single parameter by specifying the parameter name.
To get information about more than one parameter at a time, use the
`GetParameters` operation.
"""
def get_parameter(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetParameter", input, options)
end
@doc """
Retrieves the history of all changes to a parameter.
If you change the KMS key alias for the KMS key used to encrypt a parameter,
then you must also update the key alias the parameter uses to reference KMS.
Otherwise, `GetParameterHistory` retrieves whatever the original key alias was
referencing.
"""
def get_parameter_history(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetParameterHistory", input, options)
end
@doc """
Get information about one or more parameters by specifying multiple parameter
names.
To get information about a single parameter, you can use the `GetParameter`
operation instead.
"""
def get_parameters(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetParameters", input, options)
end
@doc """
Retrieve information about one or more parameters in a specific hierarchy.
Request results are returned on a best-effort basis. If you specify `MaxResults`
in the request, the response includes information up to the limit specified. The
number of items returned, however, can be between zero and the value of
`MaxResults`. If the service reaches an internal limit while processing the
results, it stops the operation and returns the matching values up to that point
and a `NextToken`. You can specify the `NextToken` in a subsequent call to get
the next set of results.
"""
def get_parameters_by_path(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetParametersByPath", input, options)
end
@doc """
Retrieves information about a patch baseline.
"""
def get_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetPatchBaseline", input, options)
end
@doc """
Retrieves the patch baseline that should be used for the specified patch group.
"""
def get_patch_baseline_for_patch_group(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetPatchBaselineForPatchGroup", input, options)
end
@doc """
`ServiceSetting` is an account-level setting for an Amazon Web Services service.
This setting defines how a user interacts with or uses a service or a feature of
a service. For example, if an Amazon Web Services service charges money to the
account based on feature or service usage, then the Amazon Web Services service
team might create a default setting of `false`. This means the user can't use
this feature unless they change the setting to `true` and intentionally opt in
for a paid feature.
Services map a `SettingId` object to a setting value. Amazon Web Services
services teams define the default value for a `SettingId`. You can't create a
new `SettingId`, but you can overwrite the default value if you have the
`ssm:UpdateServiceSetting` permission for the setting. Use the
`UpdateServiceSetting` API operation to change the default setting. Or use the
`ResetServiceSetting` to change the value back to the original value defined by
the Amazon Web Services service team.
Query the current service setting for the Amazon Web Services account.
"""
def get_service_setting(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "GetServiceSetting", input, options)
end
@doc """
A parameter label is a user-defined alias to help you manage different versions
of a parameter.
When you modify a parameter, Amazon Web Services Systems Manager automatically
saves a new version and increments the version number by one. A label can help
you remember the purpose of a parameter when there are multiple versions.
Parameter labels have the following requirements and restrictions.
* A version of a parameter can have a maximum of 10 labels.
* You can't attach the same label to different versions of the same
parameter. For example, if version 1 has the label Production, then you can't
attach Production to version 2.
* You can move a label from one version of a parameter to another.
* You can't create a label when you create a new parameter. You must
attach a label to a specific version of a parameter.
* If you no longer want to use a parameter label, then you can
either delete it or move it to a different version of a parameter.
* A label can have a maximum of 100 characters.
* Labels can contain letters (case sensitive), numbers, periods (.),
hyphens (-), or underscores (_).
* Labels can't begin with a number, "`aws`" or "`ssm`" (not case
sensitive). If a label fails to meet these requirements, then the label isn't
associated with a parameter and the system displays it in the list of
InvalidLabels.
"""
def label_parameter_version(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "LabelParameterVersion", input, options)
end
@doc """
Retrieves all versions of an association for a specific association ID.
"""
def list_association_versions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListAssociationVersions", input, options)
end
@doc """
Returns all State Manager associations in the current Amazon Web Services
account and Amazon Web Services Region.
You can limit the results to a specific State Manager association document or
managed node by specifying a filter. State Manager is a capability of Amazon Web
Services Systems Manager.
"""
def list_associations(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListAssociations", input, options)
end
@doc """
An invocation is copy of a command sent to a specific managed node.
A command can apply to one or more managed nodes. A command invocation applies
to one managed node. For example, if a user runs `SendCommand` against three
managed nodes, then a command invocation is created for each requested managed
node ID. `ListCommandInvocations` provide status about command execution.
"""
def list_command_invocations(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListCommandInvocations", input, options)
end
@doc """
Lists the commands requested by users of the Amazon Web Services account.
"""
def list_commands(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListCommands", input, options)
end
@doc """
For a specified resource ID, this API operation returns a list of compliance
statuses for different resource types.
Currently, you can only specify one resource ID per call. List results depend on
the criteria specified in the filter.
"""
def list_compliance_items(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListComplianceItems", input, options)
end
@doc """
Returns a summary count of compliant and non-compliant resources for a
compliance type.
For example, this call can return State Manager associations, patches, or custom
compliance types according to the filter criteria that you specify.
"""
def list_compliance_summaries(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListComplianceSummaries", input, options)
end
@doc """
Information about approval reviews for a version of a change template in Change
Manager.
"""
def list_document_metadata_history(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListDocumentMetadataHistory", input, options)
end
@doc """
List all versions for a document.
"""
def list_document_versions(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListDocumentVersions", input, options)
end
@doc """
Returns all Systems Manager (SSM) documents in the current Amazon Web Services
account and Amazon Web Services Region.
You can limit the results of this request by using a filter.
"""
def list_documents(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListDocuments", input, options)
end
@doc """
A list of inventory items returned by the request.
"""
def list_inventory_entries(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListInventoryEntries", input, options)
end
@doc """
Returns a list of all OpsItem events in the current Amazon Web Services Region
and Amazon Web Services account.
You can limit the results to events associated with specific OpsItems by
specifying a filter.
"""
def list_ops_item_events(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListOpsItemEvents", input, options)
end
@doc """
Lists all related-item resources associated with a Systems Manager OpsCenter
OpsItem.
OpsCenter is a capability of Amazon Web Services Systems Manager.
"""
def list_ops_item_related_items(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListOpsItemRelatedItems", input, options)
end
@doc """
Amazon Web Services Systems Manager calls this API operation when displaying all
Application Manager OpsMetadata objects or blobs.
"""
def list_ops_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListOpsMetadata", input, options)
end
@doc """
Returns a resource-level summary count.
The summary includes information about compliant and non-compliant statuses and
detailed compliance-item severity counts, according to the filter criteria you
specify.
"""
def list_resource_compliance_summaries(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListResourceComplianceSummaries", input, options)
end
@doc """
Lists your resource data sync configurations.
Includes information about the last time a sync attempted to start, the last
sync status, and the last time a sync successfully completed.
The number of sync configurations might be too large to return using a single
call to `ListResourceDataSync`. You can limit the number of sync configurations
returned by using the `MaxResults` parameter. To determine whether there are
more sync configurations to list, check the value of `NextToken` in the output.
If there are more sync configurations to list, you can request them by
specifying the `NextToken` returned in the call to the parameter of a subsequent
call.
"""
def list_resource_data_sync(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListResourceDataSync", input, options)
end
@doc """
Returns a list of the tags assigned to the specified resource.
For information about the ID format for each supported resource type, see
`AddTagsToResource`.
"""
def list_tags_for_resource(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ListTagsForResource", input, options)
end
@doc """
Shares a Amazon Web Services Systems Manager document (SSM document)publicly or
privately.
If you share a document privately, you must specify the Amazon Web Services user
account IDs for those people who can use the document. If you share a document
publicly, you must specify *All* as the account ID.
"""
def modify_document_permission(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ModifyDocumentPermission", input, options)
end
@doc """
Registers a compliance type and other compliance details on a designated
resource.
This operation lets you register custom compliance details with a resource. This
call overwrites existing compliance information on the resource, so you must
provide a full list of compliance items each time that you send the request.
ComplianceType can be one of the following:
* ExecutionId: The execution ID when the patch, association, or
custom compliance item was applied.
* ExecutionType: Specify patch, association, or Custom:`string`.
* ExecutionTime. The time the patch, association, or custom
compliance item was applied to the managed node.
* Id: The patch, association, or custom compliance ID.
* Title: A title.
* Status: The status of the compliance item. For example, `approved`
for patches, or `Failed` for associations.
* Severity: A patch severity. For example, `critical`.
* DocumentName: An SSM document name. For example,
`AWS-RunPatchBaseline`.
* DocumentVersion: An SSM document version number. For example, 4.
* Classification: A patch classification. For example, `security
updates`.
* PatchBaselineId: A patch baseline ID.
* PatchSeverity: A patch severity. For example, `Critical`.
* PatchState: A patch state. For example,
`InstancesWithFailedPatches`.
* PatchGroup: The name of a patch group.
* InstalledTime: The time the association, patch, or custom
compliance item was applied to the resource. Specify the time by using the
following format: yyyy-MM-dd'T'HH:mm:ss'Z'
"""
def put_compliance_items(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "PutComplianceItems", input, options)
end
@doc """
Bulk update custom inventory items on one or more managed nodes.
The request adds an inventory item, if it doesn't already exist, or updates an
inventory item, if it does exist.
"""
def put_inventory(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "PutInventory", input, options)
end
@doc """
Add a parameter to the system.
"""
def put_parameter(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "PutParameter", input, options)
end
@doc """
Defines the default patch baseline for the relevant operating system.
To reset the Amazon Web Services-predefined patch baseline as the default,
specify the full patch baseline Amazon Resource Name (ARN) as the baseline ID
value. For example, for CentOS, specify
`arn:aws:ssm:us-east-2:733109147000:patchbaseline/pb-0574b43a65ea646ed` instead
of `pb-0574b43a65ea646ed`.
"""
def register_default_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "RegisterDefaultPatchBaseline", input, options)
end
@doc """
Registers a patch baseline for a patch group.
"""
def register_patch_baseline_for_patch_group(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "RegisterPatchBaselineForPatchGroup", input, options)
end
@doc """
Registers a target with a maintenance window.
"""
def register_target_with_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(
client,
metadata(),
"RegisterTargetWithMaintenanceWindow",
input,
options
)
end
@doc """
Adds a new task to a maintenance window.
"""
def register_task_with_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "RegisterTaskWithMaintenanceWindow", input, options)
end
@doc """
Removes tag keys from the specified resource.
"""
def remove_tags_from_resource(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "RemoveTagsFromResource", input, options)
end
@doc """
`ServiceSetting` is an account-level setting for an Amazon Web Services service.
This setting defines how a user interacts with or uses a service or a feature of
a service. For example, if an Amazon Web Services service charges money to the
account based on feature or service usage, then the Amazon Web Services service
team might create a default setting of "false". This means the user can't use
this feature unless they change the setting to "true" and intentionally opt in
for a paid feature.
Services map a `SettingId` object to a setting value. Amazon Web Services
services teams define the default value for a `SettingId`. You can't create a
new `SettingId`, but you can overwrite the default value if you have the
`ssm:UpdateServiceSetting` permission for the setting. Use the
`GetServiceSetting` API operation to view the current value. Use the
`UpdateServiceSetting` API operation to change the default setting.
Reset the service setting for the account to the default value as provisioned by
the Amazon Web Services service team.
"""
def reset_service_setting(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ResetServiceSetting", input, options)
end
@doc """
Reconnects a session to a managed node after it has been disconnected.
Connections can be resumed for disconnected sessions, but not terminated
sessions.
This command is primarily for use by client machines to automatically reconnect
during intermittent network issues. It isn't intended for any other use.
"""
def resume_session(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "ResumeSession", input, options)
end
@doc """
Sends a signal to an Automation execution to change the current behavior or
status of the execution.
"""
def send_automation_signal(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "SendAutomationSignal", input, options)
end
@doc """
Runs commands on one or more managed nodes.
"""
def send_command(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "SendCommand", input, options)
end
@doc """
Runs an association immediately and only one time.
This operation can be helpful when troubleshooting associations.
"""
def start_associations_once(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "StartAssociationsOnce", input, options)
end
@doc """
Initiates execution of an Automation runbook.
"""
def start_automation_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "StartAutomationExecution", input, options)
end
@doc """
Creates a change request for Change Manager.
The Automation runbooks specified in the change request run only after all
required approvals for the change request have been received.
"""
def start_change_request_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "StartChangeRequestExecution", input, options)
end
@doc """
Initiates a connection to a target (for example, a managed node) for a Session
Manager session.
Returns a URL and token that can be used to open a WebSocket connection for
sending input and receiving outputs.
Amazon Web Services CLI usage: `start-session` is an interactive command that
requires the Session Manager plugin to be installed on the client machine making
the call. For information, see [Install the Session Manager plugin for the Amazon Web Services
CLI](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html)
in the *Amazon Web Services Systems Manager User Guide*.
Amazon Web Services Tools for PowerShell usage: Start-SSMSession isn't currently
supported by Amazon Web Services Tools for PowerShell on Windows local machines.
"""
def start_session(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "StartSession", input, options)
end
@doc """
Stop an Automation that is currently running.
"""
def stop_automation_execution(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "StopAutomationExecution", input, options)
end
@doc """
Permanently ends a session and closes the data connection between the Session
Manager client and SSM Agent on the managed node.
A terminated session isn't be resumed.
"""
def terminate_session(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "TerminateSession", input, options)
end
@doc """
Remove a label or labels from a parameter.
"""
def unlabel_parameter_version(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UnlabelParameterVersion", input, options)
end
@doc """
Updates an association.
You can update the association name and version, the document version, schedule,
parameters, and Amazon Simple Storage Service (Amazon S3) output.
In order to call this API operation, your Identity and Access Management (IAM)
user account, group, or role must be configured with permission to call the
`DescribeAssociation` API operation. If you don't have permission to call
`DescribeAssociation`, then you receive the following error: `An error occurred
(AccessDeniedException) when calling the UpdateAssociation operation: User:
<user_arn> isn't authorized to perform: ssm:DescribeAssociation on resource:
<resource_arn>`
When you update an association, the association immediately runs against the
specified targets.
"""
def update_association(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateAssociation", input, options)
end
@doc """
Updates the status of the Amazon Web Services Systems Manager document (SSM
document) associated with the specified managed node.
`UpdateAssociationStatus` is primarily used by the Amazon Web Services Systems
Manager Agent (SSM Agent) to report status updates about your associations and
is only used for associations created with the `InstanceId` legacy parameter.
"""
def update_association_status(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateAssociationStatus", input, options)
end
@doc """
Updates one or more values for an SSM document.
"""
def update_document(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateDocument", input, options)
end
@doc """
Set the default version of a document.
"""
def update_document_default_version(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateDocumentDefaultVersion", input, options)
end
@doc """
Updates information related to approval reviews for a specific version of a
change template in Change Manager.
"""
def update_document_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateDocumentMetadata", input, options)
end
@doc """
Updates an existing maintenance window.
Only specified parameters are modified.
The value you specify for `Duration` determines the specific end time for the
maintenance window based on the time it begins. No maintenance window tasks are
permitted to start after the resulting endtime minus the number of hours you
specify for `Cutoff`. For example, if the maintenance window starts at 3 PM, the
duration is three hours, and the value you specify for `Cutoff` is one hour, no
maintenance window tasks can start after 5 PM.
"""
def update_maintenance_window(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateMaintenanceWindow", input, options)
end
@doc """
Modifies the target of an existing maintenance window.
You can change the following:
* Name
* Description
* Owner
* IDs for an ID target
* Tags for a Tag target
* From any supported tag type to another. The three supported tag
types are ID target, Tag target, and resource group. For more information, see
`Target`.
If a parameter is null, then the corresponding field isn't modified.
"""
def update_maintenance_window_target(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateMaintenanceWindowTarget", input, options)
end
@doc """
Modifies a task assigned to a maintenance window.
You can't change the task type, but you can change the following values:
* `TaskARN`. For example, you can change a `RUN_COMMAND` task from
`AWS-RunPowerShellScript` to `AWS-RunShellScript`.
* `ServiceRoleArn`
* `TaskInvocationParameters`
* `Priority`
* `MaxConcurrency`
* `MaxErrors`
One or more targets must be specified for maintenance window Run Command-type
tasks. Depending on the task, targets are optional for other maintenance window
task types (Automation, Lambda, and Step Functions). For more information about
running tasks that don't specify targets, see [Registering maintenance window tasks without
targets](https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html)
in the *Amazon Web Services Systems Manager User Guide*.
If the value for a parameter in `UpdateMaintenanceWindowTask` is null, then the
corresponding field isn't modified. If you set `Replace` to true, then all
fields required by the `RegisterTaskWithMaintenanceWindow` operation are
required for this request. Optional fields that aren't specified are set to
null.
When you update a maintenance window task that has options specified in
`TaskInvocationParameters`, you must provide again all the
`TaskInvocationParameters` values that you want to retain. The values you don't
specify again are removed. For example, suppose that when you registered a Run
Command task, you specified `TaskInvocationParameters` values for `Comment`,
`NotificationConfig`, and `OutputS3BucketName`. If you update the maintenance
window task and specify only a different `OutputS3BucketName` value, the values
for `Comment` and `NotificationConfig` are removed.
"""
def update_maintenance_window_task(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateMaintenanceWindowTask", input, options)
end
@doc """
Changes the Identity and Access Management (IAM) role that is assigned to the
on-premises server, edge device, or virtual machines (VM).
IAM roles are first assigned to these hybrid nodes during the activation
process. For more information, see `CreateActivation`.
"""
def update_managed_instance_role(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateManagedInstanceRole", input, options)
end
@doc """
Edit or change an OpsItem.
You must have permission in Identity and Access Management (IAM) to update an
OpsItem. For more information, see [Getting started with OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html)
in the *Amazon Web Services Systems Manager User Guide*.
Operations engineers and IT professionals use Amazon Web Services Systems
Manager OpsCenter to view, investigate, and remediate operational issues
impacting the performance and health of their Amazon Web Services resources. For
more information, see
[OpsCenter](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter.html)
in the *Amazon Web Services Systems Manager User Guide*.
"""
def update_ops_item(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateOpsItem", input, options)
end
@doc """
Amazon Web Services Systems Manager calls this API operation when you edit
OpsMetadata in Application Manager.
"""
def update_ops_metadata(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateOpsMetadata", input, options)
end
@doc """
Modifies an existing patch baseline.
Fields not specified in the request are left unchanged.
For information about valid key-value pairs in `PatchFilters` for each supported
operating system type, see `PatchFilter`.
"""
def update_patch_baseline(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdatePatchBaseline", input, options)
end
@doc """
Update a resource data sync.
After you create a resource data sync for a Region, you can't change the account
options for that sync. For example, if you create a sync in the us-east-2 (Ohio)
Region and you choose the `Include only the current account` option, you can't
edit that sync later and choose the `Include all accounts from my Organizations
configuration` option. Instead, you must delete the first resource data sync,
and create a new one.
This API operation only supports a resource data sync that was created with a
SyncFromSource `SyncType`.
"""
def update_resource_data_sync(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateResourceDataSync", input, options)
end
@doc """
`ServiceSetting` is an account-level setting for an Amazon Web Services service.
This setting defines how a user interacts with or uses a service or a feature of
a service. For example, if an Amazon Web Services service charges money to the
account based on feature or service usage, then the Amazon Web Services service
team might create a default setting of "false". This means the user can't use
this feature unless they change the setting to "true" and intentionally opt in
for a paid feature.
Services map a `SettingId` object to a setting value. Amazon Web Services
services teams define the default value for a `SettingId`. You can't create a
new `SettingId`, but you can overwrite the default value if you have the
`ssm:UpdateServiceSetting` permission for the setting. Use the
`GetServiceSetting` API operation to view the current value. Or, use the
`ResetServiceSetting` to change the value back to the original value defined by
the Amazon Web Services service team.
Update the service setting for the account.
"""
def update_service_setting(%Client{} = client, input, options \\ []) do
Request.request_post(client, metadata(), "UpdateServiceSetting", input, options)
end
end
|
lib/aws/generated/ssm.ex
| 0.902295 | 0.557905 |
ssm.ex
|
starcoder
|
defmodule CyberSourceSDK.Helper do
@moduledoc """
Small utility functions
"""
@doc """
Convert a Map that have the keys as strings to atoms
## Examples
iex> CyberSourceSDK.Helper.convert_map_to_key_atom(%{"a" => 3, "b" => 5})
%{a: 3, b: 5}
"""
def convert_map_to_key_atom(string_key_map) when is_map(string_key_map) do
for {key, val} <- string_key_map, into: %{}, do: {String.to_atom(key), convert_map_to_key_atom(val)}
end
def convert_map_to_key_atom(list_maps) when is_list(list_maps) do
Enum.map(list_maps, fn (map) -> convert_map_to_key_atom(map) end)
end
def convert_map_to_key_atom(string_key_map) when is_number(string_key_map) or is_nil(string_key_map) do
string_key_map
end
def convert_map_to_key_atom(value) do
if String.valid?(value) do
value
else
Kernel.inspect(value) # Convert to string
end
end
@doc """
Decode Base64 string to JSON structure
## Examples
iex> CyberSourceSDK.Helper.json_from_base64("eyJhIjogMiwgImIiOiAzfQ==")
{:ok, %{a: 2, b: 3}}
"""
def json_from_base64(base64_string) do
case Base.decode64(base64_string) do
{:ok, json} ->
case Poison.Parser.parse(json) do
{:ok, json} -> {:ok, convert_map_to_key_atom(json)}
{:error, reason} -> {:error, reason}
end
_ -> {:error, :bad_base64_encoding}
end
end
@doc """
Check what type of payment is: Android Pay or Apple Pay
## Results
- `{:ok, :android_pay}`
- `{:ok, :apple_pay}`
- `{:error, :not_found}`
"""
def check_payment_type(encrypted_payload) do
case json_from_base64(encrypted_payload) do
{:ok, data} ->
header = Map.get(data, :header)
signature = Map.get(data, :signature)
publicKeyHash = Map.get(data, :publicKeyHash)
cond do
!is_nil(header) && !is_nil(signature) -> {:ok, :apple_pay}
!is_nil(publicKeyHash) -> {:ok, :android_pay}
true -> {:ok, :not_found_payment_type}
end
{:error, _reason} -> {:error, :invalid_base64_or_json}
end
end
@doc """
Invalid configuration message error
"""
def invalid_merchant_configuration() do
{:error, "Invalid merchant configuration"}
end
end
|
lib/cybersource-sdk/helper.ex
| 0.771843 | 0.517144 |
helper.ex
|
starcoder
|
defmodule Trifolium.Genus do
@moduledoc """
Module to be used to interact with Trefle [Genus](https://docs.trefle.io/reference/#tag/Genus) related endpoints.
"""
alias Trifolium.Config
alias Trifolium.API
@endpoint_path "api/v1/genus/"
@http_client Config.http_client()
@doc """
List every possible `Genus`.
This endpoint IS paginated, using a optional keyword parameter. By default, the page 1 is returned.
"""
@spec all(page: non_neg_integer(), filter: %{}, order: %{}) :: API.response()
def all(opts \\ []) do
@http_client.get(
get_path(),
[],
params: API.build_query_params(opts)
)
|> API.parse_response()
end
@doc """
Find a specific `Genus` according to its `id` or `slug`.
"""
@spec find(non_neg_integer() | String.t()) :: API.response()
def find(id) do
@http_client.get(
get_path("#{id}"),
[],
params: API.build_query_params()
)
|> API.parse_response()
end
@doc """
Lists all available `Plant`s for a specific `Genus` according to its `id` or `slug`.
You can paginate this endpoint, and also filter it, as explained on Trefle documentation.
You can use a `filter` or a `not_filter` like so:
```
iex()> Trifolium.Genus.plants(id, filter: %{year: year})
```
The same applies to the `order` and `range` parameters, where you just need to pass a map to it,
that it will be correctly parsed to the query parameter.
"""
@spec plants(
non_neg_integer() | String.t(),
filter: map,
filter_not: map,
order: map,
range: map,
page: non_neg_integer()
) :: API.response()
def plants(id, opts \\ []) do
@http_client.get(
get_path("#{id}/plants"),
[],
params: API.build_query_params(opts)
)
|> API.parse_response()
end
@doc """
Lists all available `Specie`s for a specific `Genus` according to its `id` or `slug`.
You can paginate this endpoint, and also filter it, as explained on Trefle documentation.
You can use a `filter` or a `not_filter` like so:
```
iex()> Trifolium.Genus.species(id, filter: %{year: year})
```
The same applies to the `order` and `range` parameters, where you just need to pass a map to it,
that it will be correctly parsed to the query parameter.
"""
@spec species(
non_neg_integer() | String.t(),
filter: map,
filter_not: map,
order: map,
range: map,
page: non_neg_integer()
) :: API.response()
def species(id, opts \\ []) do
@http_client.get(
get_path("#{id}/species"),
[],
params: API.build_query_params(opts)
)
|> API.parse_response()
end
@spec get_path(String.t()) :: String.t()
defp get_path(url \\ "") do
Config.base_url() <> @endpoint_path <> url
end
end
|
lib/trifolium/endpoints/genus.ex
| 0.833968 | 0.696139 |
genus.ex
|
starcoder
|
defmodule SanbaseWeb.Graphql.Helpers.Utils do
import Sanbase.DateTimeUtils, only: [round_datetime: 2, str_to_sec: 1]
def selector_args_to_opts(args) when is_map(args) do
opts = [aggregation: Map.get(args, :aggregation, nil)]
selector = args[:selector]
opts =
if is_map(selector) do
opts
|> maybe_add_field(:additional_filters, selector)
|> maybe_add_field(:source, selector)
else
opts
end
{:ok, opts}
end
@doc ~s"""
Works when the result is a list of elements that contain a datetime and the query arguments
have a `from` argument. In that case the first element's `datetime` is update to be
the max of `datetime` and `from` from the query.
This is used when a query to influxdb is made. Influxdb can return a timestamp
that's outside `from` - `to` interval due to its inner working with buckets
"""
def fit_from_datetime([%{datetime: _} | _] = data, %{from: from, interval: interval}) do
interval_sec = str_to_sec(interval)
from = round_datetime(from, second: interval_sec)
result =
Enum.drop_while(data, fn %{datetime: datetime} ->
datetime = round_datetime(datetime, second: interval_sec)
DateTime.compare(datetime, from) == :lt
end)
{:ok, result}
end
def fit_from_datetime(result, _args), do: {:ok, result}
@doc ~s"""
Extract the arguments passed to the root query from subfield resolution
"""
def extract_root_query_args(resolution, root_query_name) do
root_query_camelized = Absinthe.Utils.camelize(root_query_name, lower: true)
resolution.path
|> Enum.find(fn x -> is_map(x) && x.name == root_query_camelized end)
|> Map.get(:argument_data)
end
@doc ~s"""
Transform the UserTrigger structure to be more easily consumed by the API.
This is done by propagating the tags and the UserTrigger id into the Trigger
structure
"""
def transform_user_trigger(%Sanbase.Alert.UserTrigger{trigger: trigger, tags: tags} = ut) do
ut = Map.from_struct(ut)
trigger = Map.from_struct(trigger)
%{
ut
| trigger: trigger |> Map.put(:tags, tags) |> Map.put(:id, ut.id)
}
end
def replace_user_trigger_with_trigger(data) when is_map(data) do
case data do
%{user_trigger: ut} = elem when not is_nil(ut) ->
elem
|> Map.drop([:__struct__, :user_trigger])
|> Map.put(:trigger, Map.get(transform_user_trigger(ut), :trigger))
elem ->
elem
end
end
def replace_user_trigger_with_trigger(data) when is_list(data) do
data |> Enum.map(&replace_user_trigger_with_trigger/1)
end
@spec requested_fields(%Absinthe.Resolution{}) :: MapSet.t()
def requested_fields(%Absinthe.Resolution{} = resolution) do
resolution.definition.selections
|> Enum.map(fn %{name: name} -> Inflex.camelize(name, :lower) end)
|> MapSet.new()
end
def requested_fields(_), do: MapSet.new([])
# Private functions
@fields [:owner, :label, :label_fqn, :label_fqns, :blockchain, :owners, :labels]
defp maybe_add_field(opts, :additional_filters, selector) do
case Map.split(selector, @fields) do
{map, _rest} when map_size(map) > 0 ->
# Rename the plurals to singulars. This is done to simplify the
# SQL generation
map =
map
|> maybe_rename_field(:owners, :owner)
|> maybe_rename_field(:labels, :label)
|> maybe_rename_field(:label_fqns, :label_fqn)
[additional_filters: Keyword.new(map)] ++ opts
_ ->
opts
end
end
defp maybe_add_field(opts, field, selector) when is_atom(field) do
case Map.has_key?(selector, field) do
true -> [{field, Map.fetch!(selector, field)}] ++ opts
false -> opts
end
end
defp maybe_rename_field(map, old_key, new_key) do
case Map.has_key?(map, old_key) do
true ->
value = Map.get(map, old_key)
map |> Map.delete(old_key) |> Map.put(new_key, value)
false ->
map
end
end
end
|
lib/sanbase_web/graphql/helpers/utils.ex
| 0.732592 | 0.460228 |
utils.ex
|
starcoder
|
defmodule Strava.Deserializer do
@moduledoc """
Helper functions for deserializing responses into models.
"""
@doc """
Update the provided model with a deserialization of a nested value.
"""
@spec deserialize(
struct(),
atom(),
:list | :struct | :map | :date | :datetime,
module(),
map()
) :: any()
def deserialize(model, field, type, mod, options)
def deserialize(model, field, :list, mod, options) do
Map.update!(
model,
field,
&transform(&1, Map.put(options, :as, [struct(mod)]))
)
end
def deserialize(model, field, :struct, mod, options) do
Map.update!(
model,
field,
&transform(&1, Map.put(options, :as, struct(mod)))
)
end
def deserialize(model, field, :map, mod, options) do
Map.update!(
model,
field,
&Map.new(&1, fn {key, val} ->
{key, transform(val, Map.put(options, :as, struct(mod)))}
end)
)
end
def deserialize(model, field, :date, _, _options) do
with value when is_binary(value) <- Map.get(model, field),
{:ok, date, _offset} <- Date.from_iso8601(value) do
Map.put(model, field, date)
else
_ -> model
end
end
def deserialize(model, field, :datetime, _options) do
with value when is_binary(value) <- Map.get(model, field),
{:ok, datetime, _offset} <- DateTime.from_iso8601(value) do
Map.put(model, field, datetime)
else
_ -> model
end
end
if Code.ensure_loaded?(Poison.Decode) do
cond do
function_exported?(Poison.Decode, :transform, 2) ->
def transform(value, options) do
Poison.Decode.transform(value, options)
end
function_exported?(Poison.Decode, :decode, 2) ->
def transform(value, options) do
Poison.Decode.decode(value, options)
end
true ->
raise "No suitable `Poison.Decode.transform/2` or `Poison.Decode.decode/2` function found"
end
end
end
|
lib/strava/deserializer.ex
| 0.795261 | 0.439086 |
deserializer.ex
|
starcoder
|
defmodule OliWeb.Common.Table.SortableTableModel do
@moduledoc """
The model for the sortable table LiveComponent.
The model consists of the `rows` that the table will display. This must be in the form of an enumeration of
either maps or structs.
The `column_specs` are the specifications the columns that the table will render. This does not need to be a
one-to-one mapping with the attributes present in the rows, and in fact is designed to allow omitting
columns and implementing derived columns.
The `selected` item stores the currently selected item - if there is one. A client LiveView can simply choose
to ignore `selected` events, thus effectively leaving that sortable table with rows that cannot be selected.
The `sort_by_spec` and `sort_order` attributes power the sorting of the table. The `sort_by_spec` is
a reference to the current column that the rows are sorted by. Given that column specs provide the ability to
provide an arbitrary sort function to use, a complex sorting implementation where primary, secondary, and
even tertiary columns can contribute to sort order. The `sort_by_spec` cannot be nil.
The `event_suffix` is a string suffix to append to the event names that the table component will dispatch. This
is used to allow a parent LiveView to differentiate between multiple tables in situations where multiple tables
exist in the LiveView. This suffix is also appended to URI parameter names when the attributes of a sortable
table model are placed in the browser URL for live navigation.
The `id_field` is the field name from the row items that uniquely identifies a row item. This will be used
when emitting events related to a particular row item.
"""
alias OliWeb.Common.Table.ColumnSpec
# the items to display
defstruct rows: [],
# the columns to display
column_specs: [],
# the selected row
selected: nil,
# the column that is being sorted by
sort_by_spec: nil,
# the sort order, :asc or :desc
sort_order: :asc,
event_suffix: "",
# the field used to identify uniquely a row item
id_field: nil
def new(rows: rows, column_specs: column_specs, event_suffix: event_suffix, id_field: id_field) do
model =
%__MODULE__{
rows: rows,
column_specs: column_specs,
event_suffix: event_suffix,
id_field: id_field,
sort_by_spec: hd(column_specs)
}
|> sort
{:ok, model}
end
def new(
rows: rows,
column_specs: column_specs,
event_suffix: event_suffix,
id_field: id_field,
sort_by_spec: sort_by_spec
) do
model =
%__MODULE__{
rows: rows,
column_specs: column_specs,
event_suffix: event_suffix,
id_field: id_field,
sort_by_spec: sort_by_spec
}
|> sort
{:ok, model}
end
def update_selection(%__MODULE__{rows: rows, id_field: id_field} = struct, selected_id) do
Map.put(
struct,
:selected,
Enum.find(rows, fn row -> Map.get(row, id_field) == selected_id end)
)
end
def update_sort_params(%__MODULE__{sort_order: sort_order} = struct, column_name) do
current_spec_name = struct.sort_by_spec.name
case Enum.find(struct.column_specs, fn spec -> spec.name == column_name end) do
%{name: ^current_spec_name} ->
Map.put(
struct,
:sort_order,
if sort_order == :asc do
:desc
else
:asc
end
)
spec ->
Map.put(struct, :sort_by_spec, spec)
end
end
def update_sort_params_and_sort(%__MODULE__{} = struct, column_name) do
update_sort_params(struct, column_name)
|> sort
end
def sort(%__MODULE__{rows: rows, sort_by_spec: sort_by_spec, sort_order: sort_order} = struct) do
sort_fn =
case sort_by_spec.sort_fn do
nil -> ColumnSpec.default_sort_fn(sort_order, sort_by_spec)
func -> func.(sort_order, sort_by_spec)
end
struct
|> Map.put(:rows, Enum.sort(rows, sort_fn))
end
def to_params(%__MODULE__{} = struct) do
Map.put(%{}, "sort_by" <> struct.event_suffix, struct.sort_by_spec.name)
|> Map.put("sort_order" <> struct.event_suffix, struct.sort_order)
|> Map.put(
"selected" <> struct.event_suffix,
if struct.selected != nil do
Map.get(struct.selected, struct.id_field)
else
nil
end
)
end
def update_from_params(%__MODULE__{} = struct, params) do
column_names =
Enum.reduce(struct.column_specs, %{}, fn spec, m ->
Map.put(m, Atom.to_string(spec.name), spec)
end)
sort_by =
case Map.get(column_names, params["sort_by" <> struct.event_suffix]) do
nil -> struct.sort_by_spec
spec -> spec
end
sort_order =
case params["sort_order" <> struct.event_suffix] do
sort_order when sort_order in ~w(asc desc) -> String.to_existing_atom(sort_order)
_ -> struct.sort_order
end
selected =
case params["selected" <> struct.event_suffix] do
nil -> nil
id -> id
end
Map.put(struct, :sort_by_spec, sort_by)
|> Map.put(:sort_order, sort_order)
|> update_selection(selected)
|> sort
end
end
|
lib/oli_web/live/common/table/sortable_table_model.ex
| 0.861305 | 0.798854 |
sortable_table_model.ex
|
starcoder
|
defmodule PersistentVector do
@moduledoc """
`PersistentVector` is an array-like collection of values indexed by contiguous `0`-based integer index
and optimized for growing/shrinking at the end.
`PersistentVector` optimizes the following operations:
* Get element count
* Lookup element by index
* Update element by index
* Adding new element to the end
* Removing element from the end
* Enumeration
Get count operation is `O(1)`, most others are `O(log32(N))`.
`PersistentVector` is implemented as a trie with 32-way branching at each level and uses *structural sharing* for updates.
All ideas are borrowed directly from Clojure, yet the implementation (and all the bugs) are my own.
### Supported protocols
`PersistentVector` implements the following protocols/behaviors:
* `Access`
* `Collectable`
* `Enumerable`
* `Inspect`
## Usage example
iex> v = new(1..3)
#PersistentVector<count: 3, [1, 2, 3]>
iex> get(v, 0)
1
iex> v[1]
2
iex> set(v, 1, :two)
#PersistentVector<count: 3, [1, :two, 3]>
iex> v # but v remains unchanged
#PersistentVector<count: 3, [1, 2, 3]>
iex> append(v, 4)
#PersistentVector<count: 4, [1, 2, 3, 4]>
iex> remove_last(v)
#PersistentVector<count: 2, [1, 2]>
## Efficiency
Creating big vectors is OK both CPU-wise and memory-wise.
For a `100_000`-element vector the trie depths is 4
*(because `log32(100_000) = 3.3`)*, leading to fast lookup in 4 hops:
iex> big = new(100_000..0)
iex> big[70_000]
30_000
Update is also fast and efficient as it needs to build only 4 new trie nodes.
Apart from that `big1` and `big2` share majority of the elements, leading to efficient memory usage:
iex> big1 = new(100_000..0)
iex> big2 = set(big1, 70_000, "thirty thousand")
iex> big2[70_000]
"thirty thousand"
"""
use Bitwise
@shift if Mix.env() == :test, do: 2, else: 5
@block 1 <<< @shift
@mask @block - 1
@state __MODULE__
@typep shift :: pos_integer
@typedoc "Integer >= 0 for indexing elements."
@type index :: non_neg_integer
@typedoc "Stored values."
@type value :: any
@typedoc "The `PersistentVector` itself."
@type t :: %__MODULE__{count: index, shift: shift, root: tuple, tail: tuple}
defstruct(
count: 0,
shift: @shift,
root: {},
tail: {}
)
@compile {:inline, tail_start: 1}
@spec tail_start(t) :: index
defp tail_start(v = %@state{}), do: v.count - tuple_size(v.tail)
@doc "Returns empty `PersistentVector`, same as `new/0`."
@spec empty() :: t
def empty(), do: %@state{}
@doc "Creates new empty `PersistentVector`, same as `empty/0`."
@spec new() :: t
def new(), do: %@state{}
@doc "Returns `PersistentVector` with elements from `enumerable`."
@spec new(Enumerable.t) :: t
def new(enumerable), do: enumerable |> Enum.reduce(empty(), &(&2 |> append(&1)))
@doc "Returns `true` if `v` is empty and `false` otherwise."
@spec empty?(t) :: boolean
def empty?(v)
def empty?(%@state{count: 0}), do: true
def empty?(%@state{}), do: false
@doc "Returns element count in `v`."
@spec count(t) :: index
def count(v)
def count(%@state{count: count}), do: count
@doc """
Returns value of element in `v` at `0`-based `index`.
Index must be an integer and satisfy condition `0 <= index < count(v)` or `ArgumentError` will be raised.
**Note** that since `PersistentVector` implements `Access` behavior, a shorter syntax `v[i]` can be used.
*See also:* `get/3`
## Examples:
iex> v = new([:a, :b, :c])
#PersistentVector<count: 3, [:a, :b, :c]>
iex> get(v, 0)
:a
iex> v[1]
:b
iex> get(v, 10)
** (ArgumentError) Attempt to get index 10 for vector of size 3
iex> v[10]
nil
"""
@spec get(t, index) :: value | no_return
def get(v = %@state{count: count}, index)
when is_integer(index) and index >= 0 and index < count
do
fast_get(v, index)
end
def get(%@state{count: count}, i) do
raise ArgumentError, "Attempt to get index #{inspect i} for vector of size #{count}"
end
@doc """
Returns value of element in `v` at `0`-based `index` or `default` if `index >= count(v)`.
Index must be an integer and satisfy condition `0 <= index` or `ArgumentError` will be raised.
*See also:* `get/2`
## Examples:
iex> v = new([:a, :b, :c])
#PersistentVector<count: 3, [:a, :b, :c]>
iex> get(v, 0, :not_found)
:a
iex> get(v, 10, :not_found)
:not_found
iex> get(v, :bad_index, :not_found)
** (ArgumentError) Attempt to get index :bad_index for vector of size 3
"""
@impl Access
@spec get(t, index, value) :: value | no_return
def get(v = %@state{count: count}, index, _default)
when is_integer(index) and index >= 0 and index < count
do
fast_get(v, index)
end
def get(%@state{count: count}, index, default)
when is_integer(index) and index >= count
do
default
end
def get(%@state{count: count}, i, _default) do
raise ArgumentError, "Attempt to get index #{inspect i} for vector of size #{count}"
end
@doc false
@compile {:inline, fast_get: 2}
@spec fast_get(t, index) :: value
def fast_get(v, i) do
if i >= tail_start(v) do
v.tail
else
do_get(v.root, v.shift, i)
end
|> elem(i &&& @mask)
end
@spec do_get(tuple, shift, index) :: tuple
defp do_get(arr, level, i)
when level > 0
do
arr |> elem((i >>> level) &&& @mask) |> do_get(level - @shift, i)
end
defp do_get(arr, _level, _i)
# when level == 0
do
arr
end
@doc """
Returns last element in `v`, or raises `ArgumentError` if `v` is empty.
*See also:* `last/2`
## Examples:
iex> v = new(1..3)
iex> last(v)
3
iex> last(empty())
** (ArgumentError) last/1 called for empty vector
"""
@spec last(t) :: value | no_return
def last(v = %@state{count: count})
when count > 0
do
v |> fast_get(count - 1)
end
def last(%@state{})
# when count == 0
do
raise ArgumentError, "last/1 called for empty vector"
end
@doc """
Returns last element in `v`, or `default` if `v` is empty.
*See also:* `last/1`
## Examples:
iex> v = new(1..3)
iex> last(v, nil)
3
iex> last(empty(), nil)
nil
iex> last(empty(), 0)
0
"""
@spec last(t, value) :: value | nil
def last(v = %@state{count: count}, _default)
when count > 0
do
v |> fast_get(count - 1)
end
def last(%@state{}, default)
# when count == 0
do
default
end
@doc """
Returns updated `v` with element at `0`-based `index` set to `new_value`.
Index must be an integer and satisfy condition `0 <= index <= count(v)` or `ArgumentError` will be raised.
**Note** that setting `index` equal to `count(v)` is allowed and behaves as `append/2`.
## Examples:
iex> v = new([:a, :b, :c])
#PersistentVector<count: 3, [:a, :b, :c]>
iex> get(v, 1)
:b
iex> set(v, 1, :new_value)
#PersistentVector<count: 3, [:a, :new_value, :c]>
iex> set(v, 3, :append)
#PersistentVector<count: 4, [:a, :b, :c, :append]>
iex> set(v, 10, :wrong_index)
** (ArgumentError) Attempt to set index 10 for vector of size 3
"""
@spec set(t, index, value) :: t | no_return
def set(v = %@state{count: count}, index, new_value)
when is_integer(index) and index >=0 and index < count
do
if index >= tail_start(v) do
new_tail = v.tail |> put_elem(index &&& @mask, new_value)
%{v | tail: new_tail}
else
new_root = v.root |> do_set(v.shift, index, new_value)
%{v | root: new_root}
end
end
def set(v = %@state{count: count}, index, new_value)
when is_integer(index) and index == count
do
v |> append(new_value)
end
def set(%@state{count: count}, index, _new_value) do
raise ArgumentError, "Attempt to set index #{inspect index} for vector of size #{count}"
end
@spec do_set(tuple, shift, index, value) :: tuple
defp do_set(arr, level, i, val)
when level > 0
do
child_index = (i >>> level) &&& @mask
new_child = arr |> elem(child_index) |> do_set(level - @shift, i, val)
arr |> put_elem(child_index, new_child)
end
defp do_set(arr, _level, i, val)
# when level == 0
do
arr |> put_elem(i &&& @mask, val)
end
@doc """
Appends `new_value` to the end of `v`.
## Examples:
iex> v = append(empty(), 1)
#PersistentVector<count: 1, [1]>
iex> append(v, 2)
#PersistentVector<count: 2, [1, 2]>
"""
@spec append(t, value) :: t
def append(v = %@state{tail: tail}, new_value)
when tuple_size(tail) < @block
do
new_tail = tail |> Tuple.append(new_value)
%{v | count: v.count + 1, tail: new_tail}
end
def append(v = %@state{}, new_value) do
new_count = v.count + 1
new_tail = {new_value}
case v.root |> append_block(v.shift, v.tail) do
{:ok, new_root} ->
%{v | count: new_count, root: new_root, tail: new_tail}
{:overflow, tail_path} ->
new_root = {v.root, tail_path}
%{v | count: new_count, root: new_root, tail: new_tail, shift: v.shift + @shift}
end
end
@spec append_block(tuple, shift, tuple) :: {:ok | :overflow, tuple}
defp append_block(arr, level, tail)
when level > @shift
do
last_child_index = tuple_size(arr) - 1
case arr |> elem(last_child_index) |> append_block(level - @shift, tail) do
{:ok, new_child} ->
{:ok, arr |> put_elem(last_child_index, new_child)}
{:overflow, tail_path} ->
arr |> append_block_here(tail_path)
end
end
defp append_block(arr, _level, tail)
# when level == @shift
do
arr |> append_block_here(tail)
end
@compile {:inline, append_block_here: 2}
@spec append_block_here(tuple, tuple) :: {:ok | :overflow, tuple}
defp append_block_here(arr, tail_path) do
if tuple_size(arr) < @block do
{:ok, arr |> Tuple.append(tail_path)}
else
{:overflow, {tail_path}}
end
end
@doc """
Removes last element from `v` or raises `ArgumentError` if `v` is empty.
## Examples:
iex> v = new(1..3)
#PersistentVector<count: 3, [1, 2, 3]>
iex> remove_last(v)
#PersistentVector<count: 2, [1, 2]>
iex> remove_last(empty())
** (ArgumentError) Cannot remove_last from empty vector
"""
@spec remove_last(t) :: t | no_return
def remove_last(v = %@state{tail: tail})
when tuple_size(tail) > 1
do
new_tail = tail |> tuple_delete_last()
%{v | count: v.count - 1, tail: new_tail}
end
def remove_last(v = %@state{count: count})
when count > 1 # and tuple_size(tail) == 1
do
new_count = v.count - 1
{new_root, new_tail} = remove_last_block(v.root, v.shift)
if tuple_size(new_root) == 1 && v.shift > @shift do
{new_root} = new_root # remove topmost tree level
%{v | count: new_count, root: new_root, shift: v.shift - @shift, tail: new_tail}
else
%{v | count: new_count, root: new_root, tail: new_tail}
end
end
def remove_last(%@state{count: count})
when count == 1
do
empty()
end
def remove_last(%@state{})
# when count == 0
do
raise ArgumentError, "Cannot remove_last from empty vector"
end
@spec remove_last_block(tuple, shift) :: {tuple, tuple}
defp remove_last_block(arr, level)
when level > @shift
do
last_child_index = tuple_size(arr) - 1
case remove_last_block(arr |> elem(last_child_index), level - @shift) do
{{}, last_block} ->
{arr |> Tuple.delete_at(last_child_index), last_block}
{new_child, last_block} ->
{arr |> put_elem(last_child_index, new_child), last_block}
end
end
defp remove_last_block(arr, _level)
# when level == @shift
do
last_child_index = tuple_size(arr) - 1
last_block = arr |> elem(last_child_index)
new_path = arr |> Tuple.delete_at(last_child_index)
{new_path, last_block}
end
@compile {:inline, tuple_delete_last: 1}
@spec tuple_delete_last(tuple) :: tuple
defp tuple_delete_last(tuple) do
tuple |> Tuple.delete_at(tuple_size(tuple) - 1)
end
@doc """
Converts `PersistentVector` `v` to `List`.
This function is more efficient than `Enum.into/2``(v, [])` call
because it builds the list in correct order right away and
does not require `:lists.reverse/1` call at the end.
## Examples:
iex> to_list(new(1..3))
[1, 2, 3]
iex> to_list(empty())
[]
"""
@spec to_list(t) :: [value]
def to_list(v = %@state{root: root, shift: shift})
do
acc = Tuple.to_list(v.tail)
if root == {} do
acc
else
big? = shift > 2 * @shift
to_list(root, shift, tuple_size(root)-1, big?, acc)
end
end
defp to_list(arr, level, i, big?, acc)
when level > 0
do
child = elem(arr, i)
acc = to_list(child, level - @shift, tuple_size(child)-1, big?, acc)
if i > 0 do
to_list(arr, level, i-1, big?, acc)
else
acc
end
end
defp to_list(arr, _level, i, big?, acc)
# when level == 0
do
if big? do
to_list_leaf(arr, i-1, [elem(arr, i) | acc])
else
Tuple.to_list(arr) ++ acc
end
end
defp to_list_leaf(arr, i, acc) do
acc = [elem(arr, i) | acc]
if i > 0 do
to_list_leaf(arr, i-1, acc)
else
acc
end
end
@doc false # "See `Enumerable.reduce/3`"
@spec reduce(t, Enumerable.acc, Enumerable.reducer) :: Enumerable.result
def reduce(v = %@state{}, acc, fun) do
reduce_root(v.root, v.tail, v.shift, 0, acc, fun)
end
@spec reduce_root(tuple, tuple, shift, index, Enumerable.acc | Enumerable.result, Enumerable.reducer) :: Enumerable.result
defp reduce_root(arr, tail, level, i, acc = {:cont, _}, fun)
when i < tuple_size(arr)
do
reduce_root(arr, tail, level, i+1, reduce_node(elem(arr, i), level - @shift, 0, acc, fun), fun)
end
defp reduce_root(_arr, tail, _level, _i, acc = {:cont, _}, fun)
# when i == tuple_size(arr)
do
reduce_tail(tail, 0, acc, fun)
end
defp reduce_root(_arr, _tail, _level, _i, acc = {:halted, _}, _fun) do
acc
end
defp reduce_root(_arr, _tail, _level, _i, {:halt, acc}, _fun) do
{:halted, acc}
end
defp reduce_root(arr, tail, level, i, {:suspended, acc, cont_fn}, fun) do
{:suspended, acc, &reduce_root(arr, tail, level, i, cont_fn.(&1), fun)}
end
@spec reduce_tail(tuple, index, Enumerable.acc, Enumerable.reducer) :: Enumerable.result
defp reduce_tail(arr, i, {:cont, acc}, fun)
when i < tuple_size(arr)
do
reduce_tail(arr, i+1, fun.(elem(arr, i), acc), fun)
end
defp reduce_tail(_arr, _i, {:cont, acc}, _fun)
# when i == tuple_size(arr)
do
{:done, acc}
end
defp reduce_tail(_arr, _i, {:halt, acc}, _fun) do
{:halted, acc}
end
defp reduce_tail(arr, i, {:suspend, acc}, fun) do
{:suspended, acc, &reduce_tail(arr, i, &1, fun)}
end
@spec reduce_node(tuple, shift, index, Enumerable.acc | Enumerable.result, Enumerable.reducer) :: Enumerable.result
defp reduce_node(arr, level, i, acc = {:cont, _}, fun)
when level > 0 and i < tuple_size(arr)
do
reduce_node(arr, level, i+1, reduce_node(elem(arr, i), level - @shift, 0, acc, fun), fun)
end
defp reduce_node(arr, level, i, {:cont, acc}, fun)
when i < tuple_size(arr) # and level == 0
do
reduce_node(arr, level, i+1, fun.(elem(arr, i), acc), fun)
end
defp reduce_node(_arr, _level, _i, acc = {:cont, _}, _fun)
# when i == tuple_size(arr)
do
acc
end
defp reduce_node(_arr, 0, _i, {:halt, acc}, _fun) do
{:halted, acc}
end
defp reduce_node(_arr, _level, _i, acc = {:halted, _}, _fun) do
acc
end
defp reduce_node(arr, 0, i, {:suspend, acc}, fun) do
{:suspended, acc, &reduce_node(arr, 0, i, &1, fun)}
end
defp reduce_node(arr, level, i, {:suspended, acc, cont_fn}, fun) do
{:suspended, acc, &reduce_node(arr, level, i, cont_fn.(&1), fun)}
end
@behaviour Access
# `get/3` is implemented above
@impl Access
def fetch(v = %@state{count: count}, key)
when is_integer(key) and key >= 0 and key < count
do
{:ok, v |> fast_get(key)}
end
def fetch(%@state{}, _key) do
:error
end
@impl Access
@spec get_and_update(t, index, fun) :: no_return
def get_and_update(%@state{}, _key, _function) do
raise UndefinedFunctionError
end
@impl Access
@spec pop(t, index) :: no_return
def pop(%@state{}, _key) do
raise UndefinedFunctionError
end
defimpl Enumerable do
def count(v), do: {:ok, @for.count(v)}
def member?(%@for{}, _element), do: {:error, __MODULE__}
def reduce(v, acc, fun), do: @for.reduce(v, acc, fun)
end
defimpl Collectable do
def into(original) do
collector_fun = fn
v, {:cont, val} -> v |> @for.append(val)
v, :done -> v
_, :halt -> :ok
end
{original, collector_fun}
end
end
defimpl Inspect do
import Inspect.Algebra
@prefix "#" <> inspect(@for) <> "<count: "
def inspect(v, opts) do
concat [@prefix <> Integer.to_string(v.count) <> ", ", to_doc(v |> Enum.take(opts.limit + 1), opts), ">"]
end
end
end
|
lib/PersistentVector.ex
| 0.926935 | 0.846133 |
PersistentVector.ex
|
starcoder
|
defmodule SortedSet do
alias RedBlackTree
@moduledoc """
A Set implementation that always remains sorted.
SortedSet guarantees that no element appears more than once and that
enumerating over members happens in their sorted order.
"""
@behaviour Set
@default_comparator &RedBlackTree.compare_terms/2
# Define the type as opaque
@opaque t :: %__MODULE__{members: RedBlackTree, size: non_neg_integer}
@doc false
defstruct members: RedBlackTree.new, size: 0
@doc ~S"""
Returns a new `SortedSet`, initialized with the unique, sorted values of
`members`.
## Options
- `:comparator` function taking two terms and deciding their order. Passed
on to the underlying data structure, in this case a Red-Black tree. The
default is to compare based on standard Erlang term comparison. To learn
more about this option, see the examples given for
[RedBlackTree](https://github.com/SenecaSystems/red_black_tree)
## Examples
iex> SortedSet.new()
#SortedSet<[]>
iex> SortedSet.new([1,3,5])
#SortedSet<[1, 3, 5]>
iex> SortedSet.new([:a, :b, :c], comparator: fn (term1, term2) ->
...> RedBlackTree.compare_terms(term1, term2) * -1
...> end)
#SortedSet<[:c, :b, :a]>
"""
def new(members \\ [], options \\ [])
def new(members, options) do
comparator = :proplists.get_value(:comparator, options, @default_comparator)
new_set = %SortedSet{
members: RedBlackTree.new([], comparator: comparator)
}
Enum.reduce(members, new_set, fn({key, member}, set) ->
put(set, key, member)
end)
end
@doc ~S"""
Returns the number of elements in a `SortedSet`.
## Examples
iex> SortedSet.size SortedSet.new([1,3,5])
3
"""
def size(%SortedSet{size: size}) do
size
end
@doc ~S"""
Returns a `List` with all of the members of `set`.
## Examples
iex> SortedSet.to_list SortedSet.new([1,3,5])
[1,3,5]
"""
def to_list(%SortedSet{members: members}) do
Enum.reduce(members, [], fn ({key, value}, acc) ->
[{key, value} | acc]
end) |> Enum.reverse
end
@doc ~S"""
Returns a `SortedSet` with all of the members of `set` plus `element`.
## Examples
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.to_list SortedSet.put(set, 1)
[1,3,5]
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.to_list SortedSet.put(set, 2)
[1,2,3,5]
"""
def put(set = %SortedSet{}, key, element) do
new_tree = RedBlackTree.insert set.members, key, element
%SortedSet{members: new_tree, size: new_tree.size}
end
@doc ~S"""
Returns a `SortedSet` with all of the members of `sortedset` except for `element`.
## Examples
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.to_list SortedSet.delete(set, 1)
[3,5]
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.to_list SortedSet.delete(set, 2)
[1,3,5]
iex> set = SortedSet.new([])
iex> SortedSet.to_list SortedSet.delete(set, 2)
[]
"""
def delete(%SortedSet{members: members}, key) do
new_tree = RedBlackTree.delete members, key
%SortedSet{members: new_tree, size: new_tree.size}
end
## SortedSet predicate methods
@doc ~S"""
Returns `true` if `set` contains `element`
## Examples
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.member?(set, 1)
true
iex> set = SortedSet.new([1,3,5])
iex> SortedSet.member?(set, 0)
false
"""
def member?(%SortedSet{members: tree}, key) do
RedBlackTree.has_key? tree, key
end
# If the sizes are not equal, no need to check members
def equal?(%SortedSet{size: size1}, %SortedSet{size: size2}) when size1 != size2 do
false
end
@doc ~S"""
Returns `true` if all elements in `set1` are in `set2` and all elements in
`set2` are in `set1`
## Examples
iex> set1 = SortedSet.new([1,3,5])
iex> set2 = SortedSet.new([1,3,5])
iex> SortedSet.equal?(set1, set2)
true
iex> set1 = SortedSet.new([1,3,5])
iex> set2 = SortedSet.new([1,2,3,4,5])
iex> SortedSet.equal?(set1, set2)
false
"""
def equal?(%SortedSet{}=set1, %SortedSet{}=set2) do
Enum.all?(to_list(set1), fn(set1_member) ->
member? set2, set1_member
end)
end
def subset?(%SortedSet{size: size1}, %SortedSet{size: size2}) when size1 > size2 do
false
end
@doc ~S"""
Returns `true` if all elements in `set1` are in `set2`
## Examples
iex> set1 = SortedSet.new([1,3,5])
iex> set2 = SortedSet.new([1,2,3,4,5])
iex> SortedSet.subset?(set1, set2)
true
iex> set1 = SortedSet.new([1,2,3,4,5])
iex> set2 = SortedSet.new([1,3,5])
iex> SortedSet.subset?(set1, set2)
false
"""
# If set1 is larger than set2, it cannot be a subset of it
def subset?(%SortedSet{}=set1, %SortedSet{}=set2) do
Enum.all?(to_list(set1), fn(set1_member) ->
member? set2, set1_member
end)
end
@doc ~S"""
Returns `true` if no member of `set1` is in `set2`. Otherwise returns
`false`.
## Examples
iex> set1 = SortedSet.new([1,2,3,4])
iex> set2 = SortedSet.new([5,6,7,8])
iex> SortedSet.disjoint?(set1, set2)
true
iex> set1 = SortedSet.new([1,2,3,4])
iex> set2 = SortedSet.new([4,5,6,7])
iex> SortedSet.disjoint?(set1, set2)
false
"""
def disjoint?(%SortedSet{size: size1}=set1, %SortedSet{size: size2}=set2) when size1 <= size2 do
not Enum.any?(to_list(set1), fn(set1_member) ->
member?(set2, set1_member)
end)
end
def disjoint?(%SortedSet{}=set1, %SortedSet{}=set2) do
disjoint?(set2, set1)
end
## SortedSet Operations
@doc ~S"""
Returns a `SortedSet` containing the items of both `set1` and `set2`.
## Examples
iex> set1 = SortedSet.new([1,3,5,7])
iex> set2 = SortedSet.new([0,2,3,4,5])
iex> SortedSet.to_list SortedSet.union(set1, set2)
[0,1,2,3,4,5,7]
"""
def union(%SortedSet{size: size1}=set1, %SortedSet{size: size2}=set2) when size1 <= size2 do
Enum.reduce(to_list(set1), set2, fn({key, member}, new_set) ->
put(new_set, key, member)
end)
end
def union(%SortedSet{}=set1, %SortedSet{}=set2) do
union(set2, set1)
end
# If either set is empty, the intersection is the empty set
def intersection(%SortedSet{size: 0}=set1, _) do
set1
end
# If either set is empty, the intersection is the empty set
def intersection(_, %SortedSet{size: 0}=set2) do
set2
end
@doc ~S"""
Returns a `SortedSet` containing the items contained in both `set1` and
`set2`.
## Examples
iex> set1 = SortedSet.new([1,3,5,7])
iex> set2 = SortedSet.new([0,2,3,4,5])
iex> SortedSet.to_list SortedSet.intersection(set1, set2)
[3,5]
"""
def intersection(%SortedSet{size: size1}=set1, %SortedSet{size: size2}=set2) when size1 <= size2 do
Enum.reduce(to_list(set1), SortedSet.new, fn({set1_key, set1_member}, new_set) ->
if SortedSet.member?(set2, set1_key) do
SortedSet.put(new_set, set1_key, set1_member)
else
new_set
end
end)
end
def intersection(%SortedSet{}=set1, %SortedSet{}=set2) do
intersection(set2, set1)
end
@doc ~S"""
Returns a `SortedSet` containing the items in `set1` that are not in `set2`.
## Examples
iex> set1 = SortedSet.new([1,2,3,4])
iex> set2 = SortedSet.new([2,4,6,8])
iex> SortedSet.to_list SortedSet.difference(set1, set2)
[1,3]
"""
def difference(%SortedSet{size: size1}=set1, %SortedSet{size: size2}=set2) when size1 > 0 and size2 > 0 do
Enum.reduce(to_list(set1), set1, fn(set1_member, new_set) ->
if SortedSet.member?(set2, set1_member) do
delete(new_set, set1_member)
else
new_set
end
end)
end
# When the first set is empty, the difference is the empty set
def difference(%SortedSet{size: 0}=empty_set, _) do
empty_set
end
# When the other set is empty, the difference is the first set
def difference(%SortedSet{}=set1, %SortedSet{size: 0}) do
set1
end
end
defimpl Enumerable, for: SortedSet do
def count(%SortedSet{size: size}), do: {:ok, size}
def member?(%SortedSet{}=set, element), do: {:ok, SortedSet.member?(set, element)}
def reduce(%SortedSet{}=set, acc, fun) do
SortedSet.to_list(set)
|> Enumerable.List.reduce(acc, fun)
end
end
defimpl Collectable, for: SortedSet do
def into(original) do
{original, fn
set, {:cont, {new_key, new_member}} -> SortedSet.put(set, new_key, new_member)
set, :done -> set
_, :halt -> :ok
end}
end
end
# We want our own inspect so that it will hide the underlying :members and :size
# fields. Otherwise users may try to play with them directly.
defimpl Inspect, for: SortedSet do
import Inspect.Algebra
def inspect(set, opts) do
concat ["#SortedSet<", Inspect.List.inspect(SortedSet.to_list(set), opts), ">"]
end
end
|
lib/sorted_set.ex
| 0.878822 | 0.542015 |
sorted_set.ex
|
starcoder
|
defmodule SanbaseWeb.Graphql.Helpers.Utils do
alias Sanbase.DateTimeUtils
def calibrate_interval(
module,
measurement,
from,
to,
interval,
min_interval_seconds \\ 300,
data_points_count \\ 500
)
def calibrate_interval(
module,
measurement,
from,
to,
"",
min_interval_seconds,
data_points_count
) do
with {:ok, first_datetime} <- module.first_datetime(measurement) do
first_datetime = first_datetime || from
from =
max(
DateTime.to_unix(from, :second),
DateTime.to_unix(first_datetime, :second)
)
interval =
max(
div(DateTime.to_unix(to, :second) - from, data_points_count),
min_interval_seconds
)
{:ok, DateTime.from_unix!(from), to, "#{interval}s"}
end
end
def calibrate_interval(
_module,
_measurement,
from,
to,
interval,
_min_interval,
_data_points_count
) do
{:ok, from, to, interval}
end
def calibrate_interval(
module,
metric,
slug,
from,
to,
"",
min_interval_seconds,
data_points_count
) do
{:ok, first_datetime} = module.first_datetime(metric, slug)
first_datetime = first_datetime || from
from =
max(
DateTime.to_unix(from, :second),
DateTime.to_unix(first_datetime, :second)
)
interval =
max(
div(DateTime.to_unix(to, :second) - from, data_points_count),
min_interval_seconds
)
{:ok, DateTime.from_unix!(from), to, "#{interval}s"}
end
def calibrate_interval(
_module,
_metric,
_slug,
from,
to,
interval,
_min_interval,
_data_points_count
) do
{:ok, from, to, interval}
end
def calibrate_interval_with_ma_interval(
module,
measurement,
from,
to,
interval,
min_interval,
ma_base,
data_points_count \\ 500
) do
{:ok, from, to, interval} =
calibrate_interval(module, measurement, from, to, interval, min_interval, data_points_count)
ma_interval =
max(
div(
DateTimeUtils.str_to_sec(ma_base),
DateTimeUtils.str_to_sec(interval)
),
2
)
{:ok, from, to, interval, ma_interval}
end
def calibrate_incomplete_data_params(true, _module, _metric, from, to) do
{:ok, from, to}
end
def calibrate_incomplete_data_params(false, module, metric, from, to) do
case module.has_incomplete_data?(metric) do
true -> rewrite_params_incomplete_data(from, to)
false -> {:ok, from, to}
end
end
defp rewrite_params_incomplete_data(from, to) do
start_of_day = Timex.beginning_of_day(Timex.now())
case DateTime.compare(from, start_of_day) != :lt do
true ->
{:error,
"""
The time range provided [#{from} - #{to}] is contained in today. The metric
requested could have incomplete data as it's calculated since the beginning
of the day and not for the last 24 hours. If you still want to see this
data you can pass the flag `includeIncompleteData: true` in the
`timeseriesData` arguments
"""}
false ->
to = if DateTime.compare(to, start_of_day) == :gt, do: start_of_day, else: to
{:ok, from, to}
end
end
def error_details(changeset) do
changeset
|> Ecto.Changeset.traverse_errors(&format_error/1)
end
@doc ~s"""
Works when the result is a list of elements that contain a datetime and the query arguments
have a `from` argument. In that case the first element's `datetime` is update to be
the max of `datetime` and `from` from the query.
This is used when a query to influxdb is made. Influxdb can return a timestamp
that's outside `from` - `to` interval due to its inner working with buckets
"""
def fit_from_datetime([%{datetime: _} | _] = data, %{from: from}) do
result =
data
|> Enum.drop_while(fn %{datetime: datetime} ->
DateTime.compare(datetime, from) == :lt
end)
{:ok, result}
end
def fit_from_datetime(result, _args), do: {:ok, result}
@doc ~s"""
Extract the arguments passed to the root query from subfield resolution
"""
def extract_root_query_args(resolution, root_query_name) do
root_query_camelized = Absinthe.Utils.camelize(root_query_name, lower: true)
resolution.path
|> Enum.find(fn x -> is_map(x) && x.name == root_query_camelized end)
|> Map.get(:argument_data)
end
@doc ~s"""
Transform the UserTrigger structure to be more easily consumed by the API.
This is done by propagating the tags and the UserTrigger id into the Trigger
structure
"""
def transform_user_trigger(%Sanbase.Signal.UserTrigger{trigger: trigger, tags: tags} = ut) do
ut = Map.from_struct(ut)
trigger = Map.from_struct(trigger)
%{
ut
| trigger: trigger |> Map.put(:tags, tags) |> Map.put(:id, ut.id)
}
end
def replace_user_trigger_with_trigger(data) when is_map(data) do
case data do
%{user_trigger: ut} = elem when not is_nil(ut) ->
elem
|> Map.drop([:__struct__, :user_trigger])
|> Map.put(:trigger, Map.get(transform_user_trigger(ut), :trigger))
elem ->
elem
end
end
def replace_user_trigger_with_trigger(data) when is_list(data) do
data |> Enum.map(&replace_user_trigger_with_trigger/1)
end
@spec requested_fields(%Absinthe.Resolution{}) :: MapSet.t()
def requested_fields(%Absinthe.Resolution{} = resolution) do
resolution.definition.selections
|> Enum.map(fn %{name: name} -> Inflex.camelize(name, :lower) end)
|> MapSet.new()
end
# Private functions
@spec format_error(Ecto.Changeset.error()) :: String.t()
defp format_error({msg, opts}) do
Enum.reduce(opts, msg, fn {key, value}, acc ->
String.replace(acc, "%{#{key}}", to_string(inspect(value)))
end)
end
end
|
lib/sanbase_web/graphql/helpers/utils.ex
| 0.828523 | 0.409988 |
utils.ex
|
starcoder
|
defmodule ServerUtils.SentryLogger do
@moduledoc """
Logger wrapper that handles `warn` and `error` logging and sends a Sentry report. Both logging and Sentry calls will be executed asynchronously.
Sentry will need to be configured in the project that uses this dependency.
The integration with Sentry can be disabled by setting the system variable *DISABLE_SENTRY* as true.
"""
require Logger
@doc """
Logs a debug message.
Returns `:ok` or an `{:error, reason}` tuple.
"""
@spec debug(String.t()) :: atom()
def debug(message) do
Logger.debug(fn -> message end)
end
@doc """
Logs a info message.
Returns `:ok` or an `{:error, reason}` tuple.
"""
@spec info(String.t()) :: atom()
def info(message) do
Logger.info(fn -> message end)
end
@doc """
Logs a warn message.
Unless the system variable `DISABLE_SENTRY` is set, it will send the logged message as warning level to Sentry.
Returns `:ok` or an `{:error, reason}` tuple.
Returns a [Task](https://hexdocs.pm/elixir/Task.html#content) struct if Sentry is **enabled**.
"""
@spec warn(String.t()) :: atom() | Task.t()
def warn(message, opts \\ []) do
if System.get_env("DISABLE_SENTRY") do
Logger.warn(fn -> message end)
else
opts =
opts ++
[
tags: %{
env: System.get_env("ENVIRONMENT")
},
level: "warning"
]
Logger.warn(fn -> message end)
Task.start(fn -> Sentry.capture_message(message, opts) end)
end
end
@doc """
Logs a error message.
Unless the system variable `DISABLE_SENTRY` is set, it will send the logged message as error level to Sentry.
Returns `:ok` or an `{:error, reason}` tuple if Sentry is **disabled**.
Returns a [Task](https://hexdocs.pm/elixir/Task.html#content) struct if Sentry is **enabled**.
"""
@spec error(String.t()) :: atom() | Task.t()
def error(message, opts \\ []) do
if System.get_env("DISABLE_SENTRY") do
Logger.error(fn -> message end)
else
opts =
opts ++
[
tags: %{
environment: System.get_env("ENVIRONMENT")
},
level: "error"
]
Logger.error(fn -> message end)
Task.start(fn -> Sentry.capture_message(message, opts) end)
end
end
end
|
lib/logger/logger.ex
| 0.885055 | 0.484868 |
logger.ex
|
starcoder
|
defmodule Rihanna.Migration do
@max_32_bit_signed_integer (:math.pow(2, 31) |> round) - 1
@moduledoc """
A set of tools for creating the Rihanna jobs table.
Rihanna stores jobs in a table in your database. The default table name is
"rihanna_jobs". The name is configurable by either passing it as an argument
to the functions below or setting `:jobs_table_name` in Rihanna's config.
#### Using Ecto
The easiest way to create the database is with Ecto. Run `mix ecto.gen.migration create_rihanna_jobs` and make your migration look like this:
```elixir
defmodule MyApp.CreateRihannaJobs do
use Rihanna.Migration
end
```
Now you can run `mix ecto.migrate`.
#### Without Ecto
Ecto is not required to run Rihanna. If you want to create the table yourself, without Ecto, take a look at either `statements/0` or `sql/0`.
"""
defmacro __using__(opts) do
table_name = Keyword.get(opts, :table_name, Rihanna.Config.jobs_table_name()) |> to_string
quote do
use Ecto.Migration
def up() do
Enum.each(Rihanna.Migration.statements(unquote(table_name)), fn statement ->
execute(statement)
end)
end
def down() do
execute("""
DROP TABLE(#{unquote(table_name)});
""")
end
end
end
@doc """
Returns a list of SQL statements that will create the Rihanna jobs table if
executed sequentially.
By default it takes the name of the table from the application config.
You may optionally supply a table name as an argument if you want to override
this.
## Examples
> Rihanna.Migration.statements
[...]
> Rihanna.Migration.statements("my_alternative_table_name")
[...]
"""
@spec statements() :: list[String.t()]
@spec statements(String.t() | atom) :: list[String.t()]
def statements(table_name \\ Rihanna.Config.jobs_table_name())
when is_binary(table_name) or is_atom(table_name) do
[
"""
CREATE TABLE #{table_name} (
id int NOT NULL,
term bytea NOT NULL,
enqueued_at timestamp with time zone NOT NULL,
failed_at timestamp with time zone,
fail_reason text,
CONSTRAINT failed_at_required_fail_reason CHECK((failed_at IS NOT NULL AND fail_reason IS NOT NULL) OR (failed_at IS NULL and fail_reason IS NULL))
);
""",
"""
COMMENT ON CONSTRAINT failed_at_required_fail_reason ON #{table_name} IS 'When setting failed_at you must also set a fail_reason';
""",
"""
CREATE SEQUENCE #{table_name}_id_seq
START WITH 1
INCREMENT BY 1
MINVALUE 1
MAXVALUE #{@max_32_bit_signed_integer}
CACHE 1
CYCLE;
""",
"""
ALTER SEQUENCE #{table_name}_id_seq OWNED BY #{table_name}.id;
""",
"""
ALTER TABLE ONLY #{table_name} ALTER COLUMN id SET DEFAULT nextval('#{table_name}_id_seq'::regclass);
""",
"""
ALTER TABLE ONLY #{table_name}
ADD CONSTRAINT #{table_name}_pkey PRIMARY KEY (id);
"""
]
end
@doc """
Returns a string of semi-colon-terminated SQL statements that you can execute
directly to create the Rihanna jobs table.
"""
@spec sql(String.t() | atom) :: String.t()
def sql(table_name \\ Rihanna.Config.jobs_table_name()) do
Enum.join(statements(table_name), "\n")
end
end
|
lib/rihanna/migration.ex
| 0.869396 | 0.72189 |
migration.ex
|
starcoder
|
defmodule Ivy.Package do
alias Ivy.{Constraint, Logical, LSubst, LVar, Unifyable}
@behaviour Access
defstruct [s: %{}, d: %{}, c: [], vs: nil, oc: true, meta: %{}]
@type t :: %__MODULE__{
s: %{LVar.t => LSubst.t | LVar.t},
d: %{LVar.t => Domain.t},
c: [Constraint.t],
vs: [LVar.t] | nil,
oc: boolean,
meta: map()
}
def new() do
%__MODULE__{}
end
@impl Access
def fetch(package, key) do
Map.fetch(package, key)
end
@impl Access
def pop(package, key) do
Map.pop(package, key)
end
@impl Access
def get_and_update(package, key, fun) do
Map.get_and_update(package, key, fun)
end
def ext(s, u, v) do
vv = if match?(%LSubst{}, v), do: v.v, else: v
if s.oc and occurs?(s, u, vv) do
nil
else
ext_no_check(s, u, v)
end
end
def ext_no_check(s, u, v) do
put_in(s, [:s, u], v)
|> Map.update(:vs, nil, fn
vs when is_list(vs) -> [u | vs]
vs -> vs
end)
end
def unify(s, u, u), do: s
def unify(s, u, v) do
case {walk(s, u), walk(s, v)} do
{%LVar{} = u, u} -> s
{%LVar{} = u, v} -> Unifyable.unify(u, v, s)
{u, %LVar{} = v} -> Unifyable.unify(v, u, s)
{u, v} -> Unifyable.unify(u, v, s)
end
end
def walk(%__MODULE__{s: s}, %LVar{} = v),
do: walk_impl(v, Map.get(s, v), s)
def walk(_, v), do: v
defp walk_impl(lv, nil, _), do: lv
defp walk_impl(_, %LSubst{v: sv}, _), do: sv
defp walk_impl(_, %LVar{} = vp, s) do
walk_impl(vp, Map.get(s, vp), s)
end
defp walk_impl(_, vp, _), do: vp
def reify(s, v) do
Logical.reify(walk(s, v), s)
end
def occurs?(s, u, v) do
Logical.occurs?(walk(s, v), u, s)
end
def build(s, u) do
Logical.build(u, s)
end
defimpl Ivy.Bindable do
def bind(a, g) do
g.(a)
end
def mplus(a, f) do
%Ivy.Choice{a: a, f: f}
end
def take(a) do
a
end
end
defimpl Ivy.IfA do
alias Ivy.Bindable
def ifa(%@for{s: s} = b, gs, _) do
%{b | s: Enum.reduce(gs, s, &Bindable.bind(&2, &1))}
end
end
defimpl Ivy.IfU do
alias Ivy.Bindable
def ifu(%@for{s: s} = b, gs, _) do
%{b | s: Enum.reduce(gs, s, &Bindable.bind(&2, &1))}
end
end
end
|
archive/ivy/query/package.ex
| 0.734786 | 0.456107 |
package.ex
|
starcoder
|
defmodule Calcinator.Resources.Sort do
@moduledoc """
Sort in `Calcinator.Resources.query_options`
"""
alias Alembic.{Document, Error, Fetch.Includes, Source}
alias Calcinator.Resources
import Resources, only: [attribute_to_field: 2]
# Struct
defstruct field: nil,
direction: :ascending,
association: nil
# Types
@typedoc """
Keyword list of association path used to Ecto preloading
"""
@type association :: Keyword.t()
@typedoc """
The direction to sort. Default to `:ascending` per the JSONAPI spec. Can be `:descending` when the dot-separated
attribute path is prefixed with `-`.
"""
@type direction :: :ascending | :descending
@typedoc """
Name of a field in an `Ecto.Schema.t`
"""
@type field_name :: atom
@typedoc """
* `:assocation` - Keyword list of nested associations. `nil` when the `:field` is direction on the primary data.
* `:direction` - the direction to sort `:field`
* `:field` - name of the field to sort
"""
@type t :: %__MODULE__{
association: nil | association,
direction: direction,
field: field_name
}
@typedoc """
Used to convert includes used by JSONAPI to the corresponding association in Ecto.
This map does not need to be a simple conversion of the nested map of strings `Alembic.Fetch.Includes.t` to
the `Keyword.t` of `associations`, but can include completely different names or associations that the JSONAPI doesn't
even expose, so that deprecated relationships can be mapped to newer associations.
"""
@type associations_by_include :: %{Alembic.Fetch.Includes.t() => association}
@typedoc """
* `:associations_by_include` - maps the `Alembic.Fetch.Includes.t` to Keyword.t of associations.
* `:ecto_schema_module` - primary Ecto.Schema module for checking if attribute is an existent field after applying
associations.
"""
@type from_alembic_fetch_sort_options :: %{
required(:associations_by_include) => associations_by_include,
required(:ecto_schema_module) => module
}
@typedoc """
Used to convert associations used in Ecto to JSONAPI includes.
This map need not be the inverse of `associations_by_include` if the JSONAPI incoming relationships are no the same
as the outgoing relationships.
"""
@type include_by_associations :: %{association => Alembic.Fetch.Includes.t()}
# Functions
@doc """
Maps `Alembic.Fetch.Sort.t` `attribute` to `t` `field` and `Alembic.Fetch.Sort.t` `relationships` to
`t` `associations`.
When there are no `relationships`, there are no assocations
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "inserted-at"
...> },
...> %{
...> associations_by_include: %{},
...> ecto_schema_module: Calcinator.Resources.TestPost
...> }
...> )
{
:ok,
%Calcinator.Resources.Sort{field: :inserted_at}
}
When there is `relationship` it is converted to association using `:associations_by_include`
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "inserted-at",
...> relationship: "posts"
...> },
...> %{
...> associations_by_include: %{"posts" => :posts},
...> ecto_schema_module: Calcinator.Resources.TestAuthor
...> }
...> )
{
:ok,
%Calcinator.Resources.Sort{
association: :posts,
direction: :ascending,
field: :inserted_at
}
}
The relationship can also be nested and it will be converted using `:associations_by_include` too
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "inserted-at",
...> relationship: %{
...> "posts" => "comments"
...> }
...> },
...> %{
...> associations_by_include: %{
...> %{
...> "posts" => "comments"
...> } => [posts: :comments]
...> },
...> ecto_schema_module: Calcinator.Resources.TestAuthor
...> }
...> )
{
:ok,
%Calcinator.Resources.Sort{
association: [posts: :comments],
direction: :ascending,
field: :inserted_at
}
}
## Errors
If the `Alembic.Fetch.Sort.t` `relationship` is not in `:associations_by_include`, then an error is returned
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "inserted-at",
...> relationship: "author"
...> },
...> %{
...> associations_by_include: %{},
...> ecto_schema_module: Calcinator.Resources.TestPost
...> }
...> )
{
:error,
%Alembic.Document{
errors: [
%Alembic.Error{
detail: "`author` is an unknown relationship path",
meta: %{
"relationship_path" => "author"
},
source: %Alembic.Source{
parameter: "include"
},
title: "Unknown relationship path"
}
]
}
}
If the `Alembic.Fetch.Sort.t` `attribute` is not on `:ecto_schema_module` when there is no `relationship`, then an
error is returned with only the `attribute` in it
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "likes",
...> relationship: nil
...> },
...> %{
...> associations_by_include: %{},
...> ecto_schema_module: Calcinator.Resources.TestPost
...> }
...> )
{
:error,
%Alembic.Document{
errors: [
%Alembic.Error{
detail: "Does not have `likes` attribute",
meta: %{
"attribute" => "likes"
},
source: %Alembic.Source{
parameter: "sort"
},
title: "Unknown attribute"
}
]
}
}
If the `Alembic.Fetch.Sort.t` `attribute` is not on the associated `Ecto.Schema` module, than an error is returned
with both the `relationship` and `attribute` in it.
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "title",
...> relationship: "author"
...> },
...> %{
...> associations_by_include: %{
...> "author" => :author
...> },
...> ecto_schema_module: Calcinator.Resources.TestPost
...> }
...> )
{
:error,
%Alembic.Document{
errors: [
%Alembic.Error{
detail: "`author` does not have a `title` attribute",
meta: %{
"attribute" => "title",
"relationship_path" => "author"
},
source: %Alembic.Source{
parameter: "sort"
},
title: "Unknown attribute"
}
]
}
}
If the relationship is far, then the whole relationship is shown in the error
iex> Calcinator.Resources.Sort.from_alembic_fetch_sort(
...> %Alembic.Fetch.Sort{
...> attribute: "likes",
...> relationship: %{
...> "posts" => "comments"
...> }
...> },
...> %{
...> associations_by_include: %{
...> %{
...> "posts" => "comments"
...> } => [posts: :comments]
...> },
...> ecto_schema_module: Calcinator.Resources.TestAuthor
...> }
...> )
{
:error,
%Alembic.Document{
errors: [
%Alembic.Error{
detail: "`posts.comments` does not have a `likes` attribute",
meta: %{
"attribute" => "likes",
"relationship_path" => "posts.comments"
},
source: %Alembic.Source{
parameter: "sort"
},
title: "Unknown attribute"
}
]
}
}
"""
@spec from_alembic_fetch_sort(Alembic.Fetch.Sort.t(), from_alembic_fetch_sort_options) ::
{:ok, t} | {:error, Document.t()}
def from_alembic_fetch_sort(sort = %Alembic.Fetch.Sort{direction: direction, relationship: relationship}, %{
associations_by_include: associations_by_include,
ecto_schema_module: ecto_schema_module
}) do
with {:ok, association} <- association(relationship, associations_by_include),
{:ok, field} <- field(%{association: association, ecto_schema_module: ecto_schema_module, sort: sort}) do
{:ok, %__MODULE__{association: association, direction: direction, field: field}}
end
end
@doc """
Maps `t` `field` to `Alembic.Fetch.Sort.t` `attribute` and `t` `associations` to `Alembic.Fetch.Sort.t`
`relationships`.
"""
@spec to_alembic_fetch_sort(t, Resources.t()) :: {:ok, Alembic.Fetch.Sort.t()} | {:error, Document.t()}
def to_alembic_fetch_sort(%__MODULE__{association: association, direction: direction, field: field}, module) do
{
:ok,
%Alembic.Fetch.Sort{
attribute: attribute(field),
direction: direction,
relationship: relationship(module, association)
}
}
end
## Private Functions
defp association(nil, _), do: {:ok, nil}
defp association(relationship, associations_by_include) when is_binary(relationship) or is_map(relationship) do
with {:ok, [association]} <- Includes.to_preloads([relationship], associations_by_include) do
{:ok, association}
end
end
defp attribute(field) do
field
|> to_string()
|> String.replace("_", "-")
end
defp attribute_error(%Error{detail: detail, meta: meta}) do
%Error{
detail: detail,
meta: meta,
source: %Source{
parameter: "sort"
},
title: "Unknown attribute"
}
end
defp attribute_error(%Alembic.Fetch.Sort{attribute: attribute, relationship: nil}) do
attribute_error(%Error{
detail: "Does not have `#{attribute}` attribute",
meta: %{
"attribute" => attribute
}
})
end
defp attribute_error(%Alembic.Fetch.Sort{attribute: attribute, relationship: relationship}) do
relationship_path = Includes.to_string([relationship])
attribute_error(%Error{
detail: "`#{relationship_path}` does not have a `#{attribute}` attribute",
meta: %{
"attribute" => attribute,
"relationship_path" => relationship_path
}
})
end
defp attribute_error_document(sort), do: %Document{errors: [attribute_error(sort)]}
defp attribute_error_result(sort), do: {:error, attribute_error_document(sort)}
defp field(%{
association: nil,
ecto_schema_module: ecto_schema_module,
sort:
sort = %Alembic.Fetch.Sort{
attribute: attribute
}
}) do
attribute
|> attribute_to_field(ecto_schema_module)
|> case do
{:ok, field} ->
{:ok, field}
{:error, ^attribute} ->
attribute_error_result(sort)
end
end
defp field(%{
association: association,
ecto_schema_module: ecto_schema_module,
sort: sort
})
when is_atom(association) do
# Does not produce a JSON error because association being wrong is a programmer error that associatons_by_include
# has a bad associciations
%{related: related_ecto_schema_module} = ecto_schema_module.__schema__(:association, association)
field(%{association: nil, ecto_schema_module: related_ecto_schema_module, sort: sort})
end
defp field(%{
association: [{current_association, child_association}],
ecto_schema_module: ecto_schema_module,
sort: sort
}) do
# Does not produce a JSON error because association being wrong is a programmer error that associatons_by_include
# has a bad associciations
%{related: related_ecto_schema_module} = ecto_schema_module.__schema__(:association, current_association)
field(%{association: child_association, ecto_schema_module: related_ecto_schema_module, sort: sort})
end
defp relationship(_, nil), do: nil
defp relationship(module, association), do: module.association_to_include(association)
end
|
lib/calcinator/resources/sort.ex
| 0.903655 | 0.497559 |
sort.ex
|
starcoder
|
defmodule Pointers.Mixin do
@moduledoc """
If a Pointer represents an object, mixins represent data about the object. Mixins collate optional
additional information about an object. Different types of object will typically make use of
different mixins. You can see these as aspects of the data if you like.
A mixin table starts with an `id` column which references `Pointer` and forms the default primary
key. It is up to the user to choose which other fields go in the table, and thus what the mixin is for.
Use of a mixin is typically through `has_one`:
```
has_one :my_mixin, MyMixin, foreign_key: :id, references: :id
```
Sometimes, the user may wish to add fields to the primary key by using the `primary_key: true`
option to `add` in their migrations. This is permitted and in such case we call the resulting
mixin a `multimixin`. Use becomes `has_many`:
```
has_many :my_mixin, MyMixin, foreign_key: :id, references: :id
```
Thus the choice of single or multi comes down to how many times you want to store that data for
the object. A user's profile naturally lends itself to a regular `single` mixin, whereas an
object's appearance in a feed would naturally lend itself to being a multimixin since the object
may appear in many feeds.
### Declaring a mixin table type
```
defmodule My.Mixin do
use Pointers.Mixin,
otp_app: :my_app,
source: "postgres_table_name"
mixin_schema do
field :is_awesome, :boolean
end
end
```
"""
# alias Ecto.Changeset
alias Pointers.{ULID, Util}
defmacro __using__(options), do: using(__CALLER__.module, options)
@must_be_in_module "Pointers.Mixin may only be used inside a defmodule!"
def using(nil, _options), do: raise RuntimeError, description: @must_be_in_module
def using(module, options) do
otp_app = Util.get_otp_app(options)
Util.get_source(options)
config = Application.get_env(otp_app, module, [])
Module.put_attribute(module, __MODULE__, options)
pointers = emit_pointers(config ++ options)
quote do
use Ecto.Schema
require Pointers.Changesets
import Flexto
import Pointers.Mixin
# this is an attempt to help mix notice that we are using the configuration at compile
# time. In flexto, for reasons, we already had to use Application.get_env
_dummy_compile_env = Application.compile_env(unquote(otp_app), unquote(module))
unquote_splicing(pointers)
end
end
@must_use "You must use Pointers.Mixin before calling mixin_schema/1"
defmacro mixin_schema([do: body]) do
module = __CALLER__.module
schema_check_attr(Module.get_attribute(module, __MODULE__), module, body)
end
@timestamps_opts [type: :utc_datetime_usec]
@foreign_key_type ULID
defp schema_check_attr(options, module, body) when is_list(options) do
otp_app = Util.get_otp_app(options)
config = Application.get_env(otp_app, module, [])
source = Util.get_source(config ++ options)
foreign_key = Module.get_attribute(module, :foreign_key_type, @foreign_key_type)
timestamps_opts = Module.get_attribute(module, :timestamps_opts, @timestamps_opts)
quote do
@primary_key false
@foreign_key_type unquote(foreign_key)
@timestamps_opts unquote(timestamps_opts)
schema(unquote(source)) do
belongs_to :pointer, Pointers.Pointer,
foreign_key: :id,
on_replace: :update,
primary_key: true,
type: Pointers.ULID
unquote(body)
Flexto.flex_schema(unquote(otp_app))
end
end
end
defp schema_check_attr(_, _, _), do: raise ArgumentError, message: @must_use
# defines __pointers__
defp emit_pointers(config) do
otp_app = Keyword.fetch!(config, :otp_app)
[ Util.pointers_clause(:role, :mixin),
Util.pointers_clause(:otp_app, otp_app)
]
end
end
|
lib/mixin.ex
| 0.892621 | 0.875361 |
mixin.ex
|
starcoder
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.