text:
# This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: kinesis_video_archived_media
using AWS.Compat
using AWS.UUIDs

"""
    get_clip(clip_fragment_selector)
    get_clip(clip_fragment_selector, params::Dict{String,<:Any})

Downloads an MP4 file (clip) containing the archived, on-demand media from the specified
video stream over the specified time range.  Both the StreamName and the StreamARN
parameters are optional, but you must specify either the StreamName or the StreamARN when
invoking this API operation.  As a prerequisite to using GetCLip API, you must obtain an
endpoint using GetDataEndpoint, specifying GET_CLIP for the APIName parameter.  An Amazon
Kinesis video stream has the following requirements for providing data through MP4:   The
media must contain h.264 or h.265 encoded video and, optionally, AAC or G.711 encoded
audio. Specifically, the codec ID of track 1 should be V_MPEG/ISO/AVC (for h.264) or
V_MPEGH/ISO/HEVC (for H.265). Optionally, the codec ID of track 2 should be A_AAC (for AAC)
or A_MS/ACM (for G.711).   Data retention must be greater than 0.   The video track of each
fragment must contain codec private data in the Advanced Video Coding (AVC) for H.264
format and HEVC for H.265 format. For more information, see MPEG-4 specification ISO/IEC
14496-15. For information about adapting stream data to a given format, see NAL Adaptation
Flags.   The audio track (if present) of each fragment must contain codec private data in
the AAC format (AAC specification ISO/IEC 13818-7) or the MS Wave format.   You can monitor
the amount of outgoing data by monitoring the GetClip.OutgoingBytes Amazon CloudWatch
metric. For information about using CloudWatch to monitor Kinesis Video Streams, see
Monitoring Kinesis Video Streams. For pricing information, see Amazon Kinesis Video Streams
Pricing and AWS Pricing. Charges for outgoing AWS data apply.

# Arguments
- `clip_fragment_selector`: The time range of the requested clip and the source of the
  timestamps.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StreamARN"`: The Amazon Resource Name (ARN) of the stream for which to retrieve the
  media clip.  You must specify either the StreamName or the StreamARN.
- `"StreamName"`: The name of the stream for which to retrieve the media clip.  You must
  specify either the StreamName or the StreamARN.
"""
get_clip(ClipFragmentSelector; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getClip", Dict{String, Any}("ClipFragmentSelector"=>ClipFragmentSelector); aws_config=aws_config)
get_clip(ClipFragmentSelector, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getClip", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ClipFragmentSelector"=>ClipFragmentSelector), params)); aws_config=aws_config)

"""
    get_dashstreaming_session_url()
    get_dashstreaming_session_url(params::Dict{String,<:Any})

Retrieves an MPEG Dynamic Adaptive Streaming over HTTP (DASH) URL for the stream. You can
then open the URL in a media player to view the stream contents. Both the StreamName and
the StreamARN parameters are optional, but you must specify either the StreamName or the
StreamARN when invoking this API operation. An Amazon Kinesis video stream has the
following requirements for providing data through MPEG-DASH:   The media must contain h.264
or h.265 encoded video and, optionally, AAC or G.711 encoded audio. Specifically, the codec
ID of track 1 should be V_MPEG/ISO/AVC (for h.264) or V_MPEGH/ISO/HEVC (for H.265).
Optionally, the codec ID of track 2 should be A_AAC (for AAC) or A_MS/ACM (for G.711).
Data retention must be greater than 0.   The video track of each fragment must contain
codec private data in the Advanced Video Coding (AVC) for H.264 format and HEVC for H.265
format. For more information, see MPEG-4 specification ISO/IEC 14496-15. For information
about adapting stream data to a given format, see NAL Adaptation Flags.   The audio track
(if present) of each fragment must contain codec private data in the AAC format (AAC
specification ISO/IEC 13818-7) or the MS Wave format.   The following procedure shows how
to use MPEG-DASH with Kinesis Video Streams:   Get an endpoint using GetDataEndpoint,
specifying GET_DASH_STREAMING_SESSION_URL for the APIName parameter.   Retrieve the
MPEG-DASH URL using GetDASHStreamingSessionURL. Kinesis Video Streams creates an MPEG-DASH
streaming session to be used for accessing content in a stream using the MPEG-DASH
protocol. GetDASHStreamingSessionURL returns an authenticated URL (that includes an
encrypted session token) for the session's MPEG-DASH manifest (the root resource needed for
streaming with MPEG-DASH).  Don't share or store this token where an unauthorized entity
could access it. The token provides access to the content of the stream. Safeguard the
token with the same measures that you would use with your AWS credentials.  The media that
is made available through the manifest consists only of the requested stream, time range,
and format. No other media data (such as frames outside the requested window or alternate
bitrates) is made available.   Provide the URL (containing the encrypted session token) for
the MPEG-DASH manifest to a media player that supports the MPEG-DASH protocol. Kinesis
Video Streams makes the initialization fragment and media fragments available through the
manifest URL. The initialization fragment contains the codec private data for the stream,
and other data needed to set up the video or audio decoder and renderer. The media
fragments contain encoded video frames or encoded audio samples.   The media player
receives the authenticated URL and requests stream metadata and media data normally. When
the media player requests data, it calls the following actions:    GetDASHManifest:
Retrieves an MPEG DASH manifest, which contains the metadata for the media that you want to
playback.    GetMP4InitFragment: Retrieves the MP4 initialization fragment. The media
player typically loads the initialization fragment before loading any media fragments. This
fragment contains the \"fytp\" and \"moov\" MP4 atoms, and the child atoms that are needed
to initialize the media player decoder. The initialization fragment does not correspond to
a fragment in a Kinesis video stream. It contains only the codec private data for the
stream and respective track, which the media player needs to decode the media frames.
GetMP4MediaFragment: Retrieves MP4 media fragments. These fragments contain the \"moof\"
and \"mdat\" MP4 atoms and their child atoms, containing the encoded fragment's media
frames and their timestamps.   After the first media fragment is made available in a
streaming session, any fragments that don't contain the same codec private data cause an
error to be returned when those different media fragments are loaded. Therefore, the codec
private data should not change between fragments in a session. This also means that the
session fails if the fragments in a stream change from having only video to having both
audio and video.  Data retrieved with this action is billable. See Pricing for details.
 The following restrictions apply to MPEG-DASH sessions:   A streaming session URL should
not be shared between players. The service might throttle a session if multiple media
players are sharing it. For connection limits, see Kinesis Video Streams Limits.   A
Kinesis video stream can have a maximum of ten active MPEG-DASH streaming sessions. If a
new session is created when the maximum number of sessions is already active, the oldest
(earliest created) session is closed. The number of active GetMedia connections on a
Kinesis video stream does not count against this limit, and the number of active MPEG-DASH
sessions does not count against the active GetMedia connection limit.  The maximum limits
for active HLS and MPEG-DASH streaming sessions are independent of each other.      You can
monitor the amount of data that the media player consumes by monitoring the
GetMP4MediaFragment.OutgoingBytes Amazon CloudWatch metric. For information about using
CloudWatch to monitor Kinesis Video Streams, see Monitoring Kinesis Video Streams. For
pricing information, see Amazon Kinesis Video Streams Pricing and AWS Pricing. Charges for
both HLS sessions and outgoing AWS data apply. For more information about HLS, see HTTP
Live Streaming on the Apple Developer site.  If an error is thrown after invoking a Kinesis
Video Streams archived media API, in addition to the HTTP status code and the response
body, it includes the following pieces of information:     x-amz-ErrorType HTTP header –
contains a more specific error type in addition to what the HTTP status code provides.
x-amz-RequestId HTTP header – if you want to report an issue to AWS, the support team can
better diagnose the problem if given the Request Id.   Both the HTTP status code and the
ErrorType header can be utilized to make programmatic decisions about whether errors are
retry-able and under what conditions, as well as provide information on what actions the
client programmer might need to take in order to successfully try again. For more
information, see the Errors section at the bottom of this topic, as well as Common Errors.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DASHFragmentSelector"`: The time range of the requested fragment and the source of the
  timestamps. This parameter is required if PlaybackMode is ON_DEMAND or LIVE_REPLAY. This
  parameter is optional if PlaybackMode is LIVE. If PlaybackMode is LIVE, the
  FragmentSelectorType can be set, but the TimestampRange should not be set. If PlaybackMode
  is ON_DEMAND or LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be set.
- `"DisplayFragmentNumber"`: Fragments are identified in the manifest file based on their
  sequence number in the session. If DisplayFragmentNumber is set to ALWAYS, the Kinesis
  Video Streams fragment number is added to each S element in the manifest file with the
  attribute name “kvs:fn”. These fragment numbers can be used for logging or for use with
  other APIs (e.g. GetMedia and GetMediaForFragmentList). A custom MPEG-DASH media player is
  necessary to leverage these this custom attribute. The default value is NEVER.
- `"DisplayFragmentTimestamp"`: Per the MPEG-DASH specification, the wall-clock time of
  fragments in the manifest file can be derived using attributes in the manifest itself.
  However, typically, MPEG-DASH compatible media players do not properly handle gaps in the
  media timeline. Kinesis Video Streams adjusts the media timeline in the manifest file to
  enable playback of media with discontinuities. Therefore, the wall-clock time derived from
  the manifest file may be inaccurate. If DisplayFragmentTimestamp is set to ALWAYS, the
  accurate fragment timestamp is added to each S element in the manifest file with the
  attribute name “kvs:ts”. A custom MPEG-DASH media player is necessary to leverage this
  custom attribute. The default value is NEVER. When DASHFragmentSelector is
  SERVER_TIMESTAMP, the timestamps will be the server start timestamps. Similarly, when
  DASHFragmentSelector is PRODUCER_TIMESTAMP, the timestamps will be the producer start
  timestamps.
- `"Expires"`: The time in seconds until the requested session expires. This value can be
  between 300 (5 minutes) and 43200 (12 hours). When a session expires, no new calls to
  GetDashManifest, GetMP4InitFragment, or GetMP4MediaFragment can be made for that session.
  The default is 300 (5 minutes).
- `"MaxManifestFragmentResults"`: The maximum number of fragments that are returned in the
  MPEG-DASH manifest. When the PlaybackMode is LIVE, the most recent fragments are returned
  up to this value. When the PlaybackMode is ON_DEMAND, the oldest fragments are returned, up
  to this maximum number. When there are a higher number of fragments available in a live
  MPEG-DASH manifest, video players often buffer content before starting playback. Increasing
  the buffer size increases the playback latency, but it decreases the likelihood that
  rebuffering will occur during playback. We recommend that a live MPEG-DASH manifest have a
  minimum of 3 fragments and a maximum of 10 fragments. The default is 5 fragments if
  PlaybackMode is LIVE or LIVE_REPLAY, and 1,000 if PlaybackMode is ON_DEMAND.  The maximum
  value of 1,000 fragments corresponds to more than 16 minutes of video on streams with
  1-second fragments, and more than 2 1/2 hours of video on streams with 10-second fragments.
- `"PlaybackMode"`: Whether to retrieve live, live replay, or archived, on-demand data.
  Features of the three types of sessions include the following:     LIVE : For sessions of
  this type, the MPEG-DASH manifest is continually updated with the latest fragments as they
  become available. We recommend that the media player retrieve a new manifest on a
  one-second interval. When this type of session is played in a media player, the user
  interface typically displays a \"live\" notification, with no scrubber control for choosing
  the position in the playback window to display.  In LIVE mode, the newest available
  fragments are included in an MPEG-DASH manifest, even if there is a gap between fragments
  (that is, if a fragment is missing). A gap like this might cause a media player to halt or
  cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH manifest
  if they are older than the newest fragment in the playlist. If the missing fragment becomes
  available after a subsequent fragment is added to the manifest, the older fragment is not
  added, and the gap is not filled.      LIVE_REPLAY : For sessions of this type, the
  MPEG-DASH manifest is updated similarly to how it is updated for LIVE mode except that it
  starts by including fragments from a given start time. Instead of fragments being added as
  they are ingested, fragments are added as the duration of the next fragment elapses. For
  example, if the fragments in the session are two seconds long, then a new fragment is added
  to the manifest every two seconds. This mode is useful to be able to start playback from
  when an event is detected and continue live streaming media that has not yet been ingested
  as of the time of the session creation. This mode is also useful to stream previously
  archived media without being limited by the 1,000 fragment limit in the ON_DEMAND mode.
   ON_DEMAND : For sessions of this type, the MPEG-DASH manifest contains all the fragments
  for the session, up to the number that is specified in MaxMediaPlaylistFragmentResults. The
  manifest must be retrieved only once for each session. When this type of session is played
  in a media player, the user interface typically displays a scrubber control for choosing
  the position in the playback window to display.   In all playback modes, if
  FragmentSelectorType is PRODUCER_TIMESTAMP, and if there are multiple fragments with the
  same start timestamp, the fragment that has the larger fragment number (that is, the newer
  fragment) is included in the MPEG-DASH manifest. The other fragments are not included.
  Fragments that have different timestamps but have overlapping durations are still included
  in the MPEG-DASH manifest. This can lead to unexpected behavior in the media player. The
  default is LIVE.
- `"StreamARN"`: The Amazon Resource Name (ARN) of the stream for which to retrieve the
  MPEG-DASH manifest URL. You must specify either the StreamName or the StreamARN.
- `"StreamName"`: The name of the stream for which to retrieve the MPEG-DASH manifest URL.
  You must specify either the StreamName or the StreamARN.
"""
get_dashstreaming_session_url(; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getDASHStreamingSessionURL"; aws_config=aws_config)
get_dashstreaming_session_url(params::AbstractDict{String, Any}; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getDASHStreamingSessionURL", params; aws_config=aws_config)

"""
    get_hlsstreaming_session_url()
    get_hlsstreaming_session_url(params::Dict{String,<:Any})

Retrieves an HTTP Live Streaming (HLS) URL for the stream. You can then open the URL in a
browser or media player to view the stream contents. Both the StreamName and the StreamARN
parameters are optional, but you must specify either the StreamName or the StreamARN when
invoking this API operation. An Amazon Kinesis video stream has the following requirements
for providing data through HLS:   The media must contain h.264 or h.265 encoded video and,
optionally, AAC encoded audio. Specifically, the codec ID of track 1 should be
V_MPEG/ISO/AVC (for h.264) or V_MPEG/ISO/HEVC (for h.265). Optionally, the codec ID of
track 2 should be A_AAC.   Data retention must be greater than 0.   The video track of each
fragment must contain codec private data in the Advanced Video Coding (AVC) for H.264
format or HEVC for H.265 format (MPEG-4 specification ISO/IEC 14496-15). For information
about adapting stream data to a given format, see NAL Adaptation Flags.   The audio track
(if present) of each fragment must contain codec private data in the AAC format (AAC
specification ISO/IEC 13818-7).   Kinesis Video Streams HLS sessions contain fragments in
the fragmented MPEG-4 form (also called fMP4 or CMAF) or the MPEG-2 form (also called TS
chunks, which the HLS specification also supports). For more information about HLS fragment
types, see the HLS specification. The following procedure shows how to use HLS with Kinesis
Video Streams:   Get an endpoint using GetDataEndpoint, specifying
GET_HLS_STREAMING_SESSION_URL for the APIName parameter.   Retrieve the HLS URL using
GetHLSStreamingSessionURL. Kinesis Video Streams creates an HLS streaming session to be
used for accessing content in a stream using the HLS protocol. GetHLSStreamingSessionURL
returns an authenticated URL (that includes an encrypted session token) for the session's
HLS master playlist (the root resource needed for streaming with HLS).  Don't share or
store this token where an unauthorized entity could access it. The token provides access to
the content of the stream. Safeguard the token with the same measures that you would use
with your AWS credentials.  The media that is made available through the playlist consists
only of the requested stream, time range, and format. No other media data (such as frames
outside the requested window or alternate bitrates) is made available.   Provide the URL
(containing the encrypted session token) for the HLS master playlist to a media player that
supports the HLS protocol. Kinesis Video Streams makes the HLS media playlist,
initialization fragment, and media fragments available through the master playlist URL. The
initialization fragment contains the codec private data for the stream, and other data
needed to set up the video or audio decoder and renderer. The media fragments contain
H.264-encoded video frames or AAC-encoded audio samples.   The media player receives the
authenticated URL and requests stream metadata and media data normally. When the media
player requests data, it calls the following actions:    GetHLSMasterPlaylist: Retrieves an
HLS master playlist, which contains a URL for the GetHLSMediaPlaylist action for each
track, and additional metadata for the media player, including estimated bitrate and
resolution.    GetHLSMediaPlaylist: Retrieves an HLS media playlist, which contains a URL
to access the MP4 initialization fragment with the GetMP4InitFragment action, and URLs to
access the MP4 media fragments with the GetMP4MediaFragment actions. The HLS media playlist
also contains metadata about the stream that the player needs to play it, such as whether
the PlaybackMode is LIVE or ON_DEMAND. The HLS media playlist is typically static for
sessions with a PlaybackType of ON_DEMAND. The HLS media playlist is continually updated
with new fragments for sessions with a PlaybackType of LIVE. There is a distinct HLS media
playlist for the video track and the audio track (if applicable) that contains MP4 media
URLs for the specific track.     GetMP4InitFragment: Retrieves the MP4 initialization
fragment. The media player typically loads the initialization fragment before loading any
media fragments. This fragment contains the \"fytp\" and \"moov\" MP4 atoms, and the child
atoms that are needed to initialize the media player decoder. The initialization fragment
does not correspond to a fragment in a Kinesis video stream. It contains only the codec
private data for the stream and respective track, which the media player needs to decode
the media frames.    GetMP4MediaFragment: Retrieves MP4 media fragments. These fragments
contain the \"moof\" and \"mdat\" MP4 atoms and their child atoms, containing the encoded
fragment's media frames and their timestamps.   After the first media fragment is made
available in a streaming session, any fragments that don't contain the same codec private
data cause an error to be returned when those different media fragments are loaded.
Therefore, the codec private data should not change between fragments in a session. This
also means that the session fails if the fragments in a stream change from having only
video to having both audio and video.  Data retrieved with this action is billable. See
Pricing for details.    GetTSFragment: Retrieves MPEG TS fragments containing both
initialization and media data for all tracks in the stream.  If the ContainerFormat is
MPEG_TS, this API is used instead of GetMP4InitFragment and GetMP4MediaFragment to retrieve
stream media.  Data retrieved with this action is billable. For more information, see
Kinesis Video Streams pricing.      The following restrictions apply to HLS sessions:   A
streaming session URL should not be shared between players. The service might throttle a
session if multiple media players are sharing it. For connection limits, see Kinesis Video
Streams Limits.   A Kinesis video stream can have a maximum of ten active HLS streaming
sessions. If a new session is created when the maximum number of sessions is already
active, the oldest (earliest created) session is closed. The number of active GetMedia
connections on a Kinesis video stream does not count against this limit, and the number of
active HLS sessions does not count against the active GetMedia connection limit.  The
maximum limits for active HLS and MPEG-DASH streaming sessions are independent of each
other.     You can monitor the amount of data that the media player consumes by monitoring
the GetMP4MediaFragment.OutgoingBytes Amazon CloudWatch metric. For information about using
CloudWatch to monitor Kinesis Video Streams, see Monitoring Kinesis Video Streams. For
pricing information, see Amazon Kinesis Video Streams Pricing and AWS Pricing. Charges for
both HLS sessions and outgoing AWS data apply. For more information about HLS, see HTTP
Live Streaming on the Apple Developer site.  If an error is thrown after invoking a Kinesis
Video Streams archived media API, in addition to the HTTP status code and the response
body, it includes the following pieces of information:     x-amz-ErrorType HTTP header –
contains a more specific error type in addition to what the HTTP status code provides.
x-amz-RequestId HTTP header – if you want to report an issue to AWS, the support team can
better diagnose the problem if given the Request Id.   Both the HTTP status code and the
ErrorType header can be utilized to make programmatic decisions about whether errors are
retry-able and under what conditions, as well as provide information on what actions the
client programmer might need to take in order to successfully try again. For more
information, see the Errors section at the bottom of this topic, as well as Common Errors.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ContainerFormat"`: Specifies which format should be used for packaging the media.
  Specifying the FRAGMENTED_MP4 container format packages the media into MP4 fragments (fMP4
  or CMAF). This is the recommended packaging because there is minimal packaging overhead.
  The other container format option is MPEG_TS. HLS has supported MPEG TS chunks since it was
  released and is sometimes the only supported packaging on older HLS players. MPEG TS
  typically has a 5-25 percent packaging overhead. This means MPEG TS typically requires 5-25
  percent more bandwidth and cost than fMP4. The default is FRAGMENTED_MP4.
- `"DiscontinuityMode"`: Specifies when flags marking discontinuities between fragments are
  added to the media playlists. Media players typically build a timeline of media content to
  play, based on the timestamps of each fragment. This means that if there is any overlap or
  gap between fragments (as is typical if HLSFragmentSelector is set to SERVER_TIMESTAMP),
  the media player timeline will also have small gaps between fragments in some places, and
  will overwrite frames in other places. Gaps in the media player timeline can cause playback
  to stall and overlaps can cause playback to be jittery. When there are discontinuity flags
  between fragments, the media player is expected to reset the timeline, resulting in the
  next fragment being played immediately after the previous fragment.  The following modes
  are supported:    ALWAYS: a discontinuity marker is placed between every fragment in the
  HLS media playlist. It is recommended to use a value of ALWAYS if the fragment timestamps
  are not accurate.    NEVER: no discontinuity markers are placed anywhere. It is recommended
  to use a value of NEVER to ensure the media player timeline most accurately maps to the
  producer timestamps.     ON_DISCONTIUNITY: a discontinuity marker is placed between
  fragments that have a gap or overlap of more than 50 milliseconds. For most playback
  scenarios, it is recommended to use a value of ON_DISCONTINUITY so that the media player
  timeline is only reset when there is a significant issue with the media timeline (e.g. a
  missing fragment).   The default is ALWAYS when HLSFragmentSelector is set to
  SERVER_TIMESTAMP, and NEVER when it is set to PRODUCER_TIMESTAMP.
- `"DisplayFragmentTimestamp"`: Specifies when the fragment start timestamps should be
  included in the HLS media playlist. Typically, media players report the playhead position
  as a time relative to the start of the first fragment in the playback session. However,
  when the start timestamps are included in the HLS media playlist, some media players might
  report the current playhead as an absolute time based on the fragment timestamps. This can
  be useful for creating a playback experience that shows viewers the wall-clock time of the
  media. The default is NEVER. When HLSFragmentSelector is SERVER_TIMESTAMP, the timestamps
  will be the server start timestamps. Similarly, when HLSFragmentSelector is
  PRODUCER_TIMESTAMP, the timestamps will be the producer start timestamps.
- `"Expires"`: The time in seconds until the requested session expires. This value can be
  between 300 (5 minutes) and 43200 (12 hours). When a session expires, no new calls to
  GetHLSMasterPlaylist, GetHLSMediaPlaylist, GetMP4InitFragment, GetMP4MediaFragment, or
  GetTSFragment can be made for that session. The default is 300 (5 minutes).
- `"HLSFragmentSelector"`: The time range of the requested fragment and the source of the
  timestamps. This parameter is required if PlaybackMode is ON_DEMAND or LIVE_REPLAY. This
  parameter is optional if PlaybackMode is LIVE. If PlaybackMode is LIVE, the
  FragmentSelectorType can be set, but the TimestampRange should not be set. If PlaybackMode
  is ON_DEMAND or LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be set.
- `"MaxMediaPlaylistFragmentResults"`: The maximum number of fragments that are returned in
  the HLS media playlists. When the PlaybackMode is LIVE, the most recent fragments are
  returned up to this value. When the PlaybackMode is ON_DEMAND, the oldest fragments are
  returned, up to this maximum number. When there are a higher number of fragments available
  in a live HLS media playlist, video players often buffer content before starting playback.
  Increasing the buffer size increases the playback latency, but it decreases the likelihood
  that rebuffering will occur during playback. We recommend that a live HLS media playlist
  have a minimum of 3 fragments and a maximum of 10 fragments. The default is 5 fragments if
  PlaybackMode is LIVE or LIVE_REPLAY, and 1,000 if PlaybackMode is ON_DEMAND.  The maximum
  value of 1,000 fragments corresponds to more than 16 minutes of video on streams with
  1-second fragments, and more than 2 1/2 hours of video on streams with 10-second fragments.
- `"PlaybackMode"`: Whether to retrieve live, live replay, or archived, on-demand data.
  Features of the three types of sessions include the following:     LIVE : For sessions of
  this type, the HLS media playlist is continually updated with the latest fragments as they
  become available. We recommend that the media player retrieve a new playlist on a
  one-second interval. When this type of session is played in a media player, the user
  interface typically displays a \"live\" notification, with no scrubber control for choosing
  the position in the playback window to display.  In LIVE mode, the newest available
  fragments are included in an HLS media playlist, even if there is a gap between fragments
  (that is, if a fragment is missing). A gap like this might cause a media player to halt or
  cause a jump in playback. In this mode, fragments are not added to the HLS media playlist
  if they are older than the newest fragment in the playlist. If the missing fragment becomes
  available after a subsequent fragment is added to the playlist, the older fragment is not
  added, and the gap is not filled.      LIVE_REPLAY : For sessions of this type, the HLS
  media playlist is updated similarly to how it is updated for LIVE mode except that it
  starts by including fragments from a given start time. Instead of fragments being added as
  they are ingested, fragments are added as the duration of the next fragment elapses. For
  example, if the fragments in the session are two seconds long, then a new fragment is added
  to the media playlist every two seconds. This mode is useful to be able to start playback
  from when an event is detected and continue live streaming media that has not yet been
  ingested as of the time of the session creation. This mode is also useful to stream
  previously archived media without being limited by the 1,000 fragment limit in the
  ON_DEMAND mode.      ON_DEMAND : For sessions of this type, the HLS media playlist contains
  all the fragments for the session, up to the number that is specified in
  MaxMediaPlaylistFragmentResults. The playlist must be retrieved only once for each session.
  When this type of session is played in a media player, the user interface typically
  displays a scrubber control for choosing the position in the playback window to display.
  In all playback modes, if FragmentSelectorType is PRODUCER_TIMESTAMP, and if there are
  multiple fragments with the same start timestamp, the fragment that has the larger fragment
  number (that is, the newer fragment) is included in the HLS media playlist. The other
  fragments are not included. Fragments that have different timestamps but have overlapping
  durations are still included in the HLS media playlist. This can lead to unexpected
  behavior in the media player. The default is LIVE.
- `"StreamARN"`: The Amazon Resource Name (ARN) of the stream for which to retrieve the HLS
  master playlist URL. You must specify either the StreamName or the StreamARN.
- `"StreamName"`: The name of the stream for which to retrieve the HLS master playlist URL.
  You must specify either the StreamName or the StreamARN.
"""
get_hlsstreaming_session_url(; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getHLSStreamingSessionURL"; aws_config=aws_config)
get_hlsstreaming_session_url(params::AbstractDict{String, Any}; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getHLSStreamingSessionURL", params; aws_config=aws_config)

"""
    get_media_for_fragment_list(fragments)
    get_media_for_fragment_list(fragments, params::Dict{String,<:Any})

Gets media for a list of fragments (specified by fragment number) from the archived data in
an Amazon Kinesis video stream.  You must first call the GetDataEndpoint API to get an
endpoint. Then send the GetMediaForFragmentList requests to this endpoint using the
--endpoint-url parameter.   The following limits apply when using the
GetMediaForFragmentList API:   A client can call GetMediaForFragmentList up to five times
per second per stream.    Kinesis Video Streams sends media data at a rate of up to 25
megabytes per second (or 200 megabits per second) during a GetMediaForFragmentList session.
    If an error is thrown after invoking a Kinesis Video Streams archived media API, in
addition to the HTTP status code and the response body, it includes the following pieces of
information:     x-amz-ErrorType HTTP header – contains a more specific error type in
addition to what the HTTP status code provides.     x-amz-RequestId HTTP header – if you
want to report an issue to AWS, the support team can better diagnose the problem if given
the Request Id.   Both the HTTP status code and the ErrorType header can be utilized to
make programmatic decisions about whether errors are retry-able and under what conditions,
as well as provide information on what actions the client programmer might need to take in
order to successfully try again. For more information, see the Errors section at the bottom
of this topic, as well as Common Errors.

# Arguments
- `fragments`: A list of the numbers of fragments for which to retrieve media. You retrieve
  these values with ListFragments.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StreamARN"`: The Amazon Resource Name (ARN) of the stream from which to retrieve
  fragment media. Specify either this parameter or the StreamName parameter.
- `"StreamName"`: The name of the stream from which to retrieve fragment media. Specify
  either this parameter or the StreamARN parameter.
"""
get_media_for_fragment_list(Fragments; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getMediaForFragmentList", Dict{String, Any}("Fragments"=>Fragments); aws_config=aws_config)
get_media_for_fragment_list(Fragments, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/getMediaForFragmentList", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Fragments"=>Fragments), params)); aws_config=aws_config)

"""
    list_fragments()
    list_fragments(params::Dict{String,<:Any})

Returns a list of Fragment objects from the specified stream and timestamp range within the
archived data. Listing fragments is eventually consistent. This means that even if the
producer receives an acknowledgment that a fragment is persisted, the result might not be
returned immediately from a request to ListFragments. However, results are typically
available in less than one second.  You must first call the GetDataEndpoint API to get an
endpoint. Then send the ListFragments requests to this endpoint using the --endpoint-url
parameter.    If an error is thrown after invoking a Kinesis Video Streams archived media
API, in addition to the HTTP status code and the response body, it includes the following
pieces of information:     x-amz-ErrorType HTTP header – contains a more specific error
type in addition to what the HTTP status code provides.     x-amz-RequestId HTTP header –
if you want to report an issue to AWS, the support team can better diagnose the problem if
given the Request Id.   Both the HTTP status code and the ErrorType header can be utilized
to make programmatic decisions about whether errors are retry-able and under what
conditions, as well as provide information on what actions the client programmer might need
to take in order to successfully try again. For more information, see the Errors section at
the bottom of this topic, as well as Common Errors.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"FragmentSelector"`: Describes the timestamp range and timestamp origin for the range of
  fragments to return.
- `"MaxResults"`: The total number of fragments to return. If the total number of fragments
  available is more than the value specified in max-results, then a
  ListFragmentsOutputNextToken is provided in the output that you can use to resume
  pagination.
- `"NextToken"`: A token to specify where to start paginating. This is the
  ListFragmentsOutputNextToken from a previously truncated response.
- `"StreamARN"`: The Amazon Resource Name (ARN) of the stream from which to retrieve a
  fragment list. Specify either this parameter or the StreamName parameter.
- `"StreamName"`: The name of the stream from which to retrieve a fragment list. Specify
  either this parameter or the StreamARN parameter.
"""
list_fragments(; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/listFragments"; aws_config=aws_config)
list_fragments(params::AbstractDict{String, Any}; aws_config::AbstractAWSConfig=global_aws_config()) = kinesis_video_archived_media("POST", "/listFragments", params; aws_config=aws_config)


text:
using OrbitalTrajectories

using Test
using LinearAlgebra

@testset "Pellegrini2016" begin
    # Values taken from Table 1 of [Pellegrini 2016, On the Computation and Accuracy of Trajectory State Transition Matrices]
    test_cases = [(
        system = (:Jupiter, :Europa),
        u0     = [-0.1017472008677258, 0., 0., 0., -0.01806028472285857, 0.],
        μ      = 2.528009215182033e-5,
        t_p    = 25.13898226959327,
        λ_max  = 2.468621114047195,
    ), (
        system = (:Jupiter, :Europa),
        u0     = [0.04867586089512202, 0., 0., 0., -0.09354853663949217, 0.],
        μ      = 2.528009215182033e-5,
        t_p    = 70.53945041512506,
        λ_max  = 2.804814246519340e7,
    ), (
        system = (:Earth, :Moon),
        u0     = [-0.013059020050628, 0., 0.07129515195874, 0., -0.526306975588415, 0.],
        μ      = 0.01215509906405700,
        t_p    = 2.517727406553485,
        λ_max  = 17.632688124231755,
    )]

    for case in test_cases
        cr3bp = CR3BP(case.system...; μ=case.μ)
        cr3bp_handcoded = HandcodedCR3BP(case.system...; μ=case.μ)

        # The u0 from the paper is given relative to secondary body, so convert here to primary body
        u0 = deepcopy(case.u0)
        u0[1] += (1 - cr3bp.props.μ)

        # Initial state
        state_cr3bp = State(cr3bp, SynodicFrame(), u0, (0., case.t_p))
        state_cr3bp_handcoded = State(cr3bp_handcoded, SynodicFrame(), u0, (0., case.t_p))

        # Compute STMs
        STM_AD = sensitivity(AD, state_cr3bp)
        STM_VE = sensitivity(VE, state_cr3bp)
        STM_VE_handcoded = sensitivity(VE, state_cr3bp_handcoded)

        # Compute the maximum eigenvalues
        λ_max_AD = maximum(norm.(eigvals(Matrix(STM_AD))))
        @test λ_max_AD ≈ case.λ_max rtol=1e-4
        λ_max_VE = maximum(norm.(eigvals(STM_VE)))
        @test λ_max_VE ≈ case.λ_max rtol=1e-4
        λ_max_VE_handcoded = maximum(norm.(eigvals(STM_VE_handcoded)))
        @test λ_max_VE_handcoded ≈ case.λ_max rtol=1e-4
    end
end

@testset "EphemerisNBP STM computation" begin
    u0 = [0.8574053516112442, 0., 0., 0., 0.47, 0.]
    dim = length(u0)
    system_nbp = EphemerisNBP(:earth, :moon)
    prob = State(system_nbp, SynodicFrame(), u0, (0., 3600.0*24))

    # Compute final STM
    STM_AD = sensitivity(AD, prob)
    STM_FD = sensitivity(FD, prob)
    @test STM_AD ≈ STM_FD rtol=1e-5

    # Compute STM trace
    STM_AD_trace = sensitivity_trace(AD, prob)
    @test extract_STMs([STM_AD_trace.sol[end]])[1] ≈ STM_AD rtol=1e-5
end

ext: jl


text:
"""
    C_iio_device_attr_read(device, attr)

Read the content of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute. Passing an empty string reads all the attributes.

# Returns
- On success, the number of bytes written to the buffer and the attribute value as a `String`.
- On error, a negative errno code is returned along an empty `String`.
- If all the attributes are being read, an array of the values above is returned.
The string may be shorter than the number of bytes returned as the conversion trims excess null characters.

# NOTE
By passing NULL (replaced by an empty string in the Julia wrapper) as the "attr" argument to iio_device_attr_read, it is now possible to read all of the attributes of a device.

The buffer is filled with one block of data per attribute of the device, by the order they appear in the iio_device structure.

The first four bytes of one block correspond to a 32-bit signed value in network order.
If negative, it corresponds to the errno code that were returned when reading the attribute;
if positive, it corresponds to the length of the data read. In that case, the rest of the block contains the data.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gaf0233eb0ef4a64ad70ebaef6328b0494)
"""
function C_iio_device_attr_read(device::Ptr{iio_device}, attr::String)
    if attr == ""; attr = C_NULL; end; # allows to read all the attributes
    buf = zeros(UInt8, BUF_SIZE);
    ret = ccall(
        (:iio_device_attr_read, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Cstring, Csize_t),
        device, attr, pointer(buf), BUF_SIZE
    );
    attr == C_NULL ? attrs = iio_decode_blocks(buf, ret) : attrs = toString(buf);
    return ret, attrs;
end

"""
    C_iio_device_attr_read_all()

THIS IS A PLACEHOLDER. THE DOCUMENTATION BELOW IS ONLY A COPY/PASTE OF THE C DOCUMENTATION.

Read the content of all device-specific attributes.

# Parameters
- dev : A pointer to an iio_device structure
- cb : A pointer to a callback function
- data : A pointer that will be passed to the callback function

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

# NOTE
This function is especially useful when used with the network backend, as all the device-specific attributes are read in one single command.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga5b1fef1333c4835942384b661f148b36)
"""
function C_iio_device_attr_read_all()
    return "PLACEHOLDER"
end

"""
    C_iio_device_attr_read_bool(device, attr)

Read the content of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, `(0, value::Bool)` is returned.
- On error, `(errno, value::Bool)` is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga96364b7c7097bb8e4656924ea896a502)
"""
function C_iio_device_attr_read_bool(device::Ptr{iio_device}, attr::String)
    value = Ref{UInt8}(0);
    ret = ccall(
        (:iio_device_attr_read_bool, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Cuchar}),
        device, attr, value
    );
    return ret, Base.convert(Bool, value[]);
end

"""
    C_iio_device_attr_read_double(device, attr)

Read the content of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, `(0, value::Float64)` is returned.
- On error, `(errno, value::Float64)` is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gab1b150a5bfa7b1ab7fd76c538e15e4da)
"""
function C_iio_device_attr_read_double(device::Ptr{iio_device}, attr::String)
    value = Ref{Float64}(0);
    ret = ccall(
        (:iio_device_attr_read_double, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Cdouble}),
        device, attr, value
    );
    return ret, value[];
end

"""
    C_iio_device_attr_read_longlong(device, attr)

Read the content of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, `(0, value::Int64)` is returned.
- On error, `(errno, value::Int64)` is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga0f7b5d21a4e40efac68e1ece44d7ba74)
"""
function C_iio_device_attr_read_longlong(device::Ptr{iio_device}, attr::String)
    value = Ref{Int64}(0);
    ret = ccall(
        (:iio_device_attr_read_longlong, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Clonglong}),
        device, attr, value
    );
    return ret, value[];
end

"""
    C_iio_device_attr_write(device, attr, value)

Set the value of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::String`           : A NULL-terminated string to set the attribute to

# Returns
- On success, the number of bytes written
- On error, a negative errno code is returned

# NOTE
By passing NULL as the "attr" argument to `iio_device_attr_write`, it is now possible to write all of the attributes of a device.

The buffer must contain one block of data per attribute of the device, by the order they appear in the iio_device structure.

The first four bytes of one block correspond to a 32-bit signed value in network order.
If negative, the attribute is not written;
if positive, it corresponds to the length of the data to write. In that case, the rest of the block must contain the data.

# WARNING
If the value given is among the available values but not working on the radio,
this function returns the success value without actually writing the value.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gaaa2d1867c15ef8f8424164d0ccea4dd8)
"""
function C_iio_device_attr_write(device::Ptr{iio_device}, attr::String, value::String)
    return ccall(
        (:iio_device_attr_write, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Cstring),
        device, attr, value
    );
end

"""
    C_iio_device_attr_write_all()

THIS IS A PLACEHOLDER. THE DOCUMENTATION BELOW IS ONLY A COPY/PASTE OF THE C DOCUMENTATION.

Set the values of all device-specific attributes.

# Parameters
- dev : A pointer to an iio_device structure
- cb : A pointer to a callback function
- data : A pointer that will be passed to the callback function

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gadfbbfafabc32d6954d3f3dfcda957735)
"""
function C_iio_device_attr_write_all()
    return "PLACEHOLDER"
end

"""
    C_iio_device_attr_write_bool(device, attr, value)

Set the value of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Bool`             : A bool value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga9f53f9d1c3dc9f87191943fcbd1a7324)
"""
function C_iio_device_attr_write_bool(device::Ptr{iio_device}, attr::String, value::Bool)
    return ccall(
        (:iio_device_attr_write_bool, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Cuchar),
        device, attr, value
    );
end

"""
    C_iio_device_attr_write_double(device, attr, value)

Set the value of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Float64`          : A double value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gacdaf529f12b46ba2a5290bbc590c8b9e)
"""
function C_iio_device_attr_write_double(device::Ptr{iio_device}, attr::String, value::Float64)
    return ccall(
        (:iio_device_attr_write_double, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Cdouble),
        device, attr, value
    );
end

"""
    C_iio_device_attr_write_longlong(device, attr, value)

Set the value of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Int64`            : A long long value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga3fcba684f6b07d3f6295759bb788c4d2)
"""
function C_iio_device_attr_write_longlong(device::Ptr{iio_device}, attr::String, value::Int64)
    return ccall(
        (:iio_device_attr_write_longlong, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Clonglong),
        device, attr, value
    );
end

"""
    C_iio_device_attr_write_raw(device, attr, value)

Set the value of the given device-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Ptr{Cvoid}`       : A pointer to the data to be written
- `size::Csize_t`           : The number of bytes to be written

# Returns
- On success, the number of bytes written
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga30829a67dcdffc902c4ba6801233e79a)
"""
function C_iio_device_attr_write_raw(device::Ptr{iio_device}, attr::String, value::Ptr{Cvoid}, size::Csize_t)
    return ccall(
        (:iio_device_attr_write_raw, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Ptr{Cvoid}, Csize_t),
        device, attr, value, size
    );
end

"""
    C_iio_device_buffer_attr_read(device, attr)

Read the content of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute. Passing an empty string reads all the attributes.

# Returns
- On success, (number_of_bytes, value::String) is returned, where number of bytes should be the length of the string.
- On error, (errno, "") is returned, where errno is a negative error code.
- If all the attributes are being read, an array of the values above is returned.
The string may be shorter than the actual number of bytes returned as the conversion trims excess null characters.

# NOTE
By passing NULL (replaced by an empty string in the Julia wrapper) as the "attr" argument to `iio_device_buffer_attr_read`, it is now possible to read all of the attributes of a device.

The buffer is filled with one block of data per attribute of the buffer, by the order they appear in the iio_device structure.

The first four bytes of one block correspond to a 32-bit signed value in network order.
If negative, it corresponds to the errno code that were returned when reading the attribute;
if positive, it corresponds to the length of the data read. In that case, the rest of the block contains the data.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gaa77d52bb9dea248cc3de682778a08a6f)
"""
function C_iio_device_buffer_attr_read(device::Ptr{iio_device}, attr::String)
    if attr == ""; attr = C_NULL; end; # allows to read all the attributes
    buf = zeros(UInt8, BUF_SIZE);
    ret = ccall(
        (:iio_device_buffer_attr_read, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Cstring, Csize_t),
        device, attr, pointer(buf), BUF_SIZE
    );
    attr == C_NULL ? attrs = iio_decode_blocks(buf, ret) : attrs = toString(buf);
    return ret, attrs;
end

"""
    C_iio_device_buffer_attr_read_all()

THIS IS A PLACEHOLDER. THE DOCUMENTATION BELOW IS ONLY A COPY/PASTE OF THE C DOCUMENTATION.

Read the content of all buffer-specific attributes.

# Parameters
- dev : A pointer to an iio_device structure
- cb : A pointer to a callback function
- data : A pointer that will be passed to the callback function

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

# NOTE
This function is especially useful when used with the network backend, as all the buffer-specific attributes are read in one single command.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gaae5bf33ad1bd1b14155eab4a018c576c)
"""
function C_iio_device_buffer_attr_read_all()
    return "PLACEHOLDER"
end

"""
    C_iio_device_buffer_attr_read_bool(device, attr)

Read the content of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, (0, value::Bool) is returned.
- On error, (errno, value::Bool) is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga92ee863b94e6f841efec3919f57f5193)
"""
function C_iio_device_buffer_attr_read_bool(device::Ptr{iio_device}, attr::String)
    value = Ref{UInt8}(0);
    ret = ccall(
        (:iio_device_buffer_attr_read_bool, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Cuchar}),
        device, attr, value
    );
    return ret, Base.convert(Bool, value[]);
end

"""
    C_iio_device_buffer_attr_read_double(device, attr)

Read the content of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, (0, value::Float64) is returned.
- On error, (errno, value::Float64) is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga44952198b73ff6b0c0c0b53d3cd6d1bd)
"""
function C_iio_device_buffer_attr_read_double(device::Ptr{iio_device}, attr::String)
    value = Ref{Float64}(0);
    ret = ccall(
        (:iio_device_buffer_attr_read_double, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Cdouble}),
        device, attr, value
    );
    return ret, value[];
end

"""
    C_iio_device_buffer_attr_read_longlong(device, attr)

Read the content of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, (0, value::Int64) is returned.
- On error, (errno, value::Int64) is returned, where errno is a negative error code. `value` should be discarded.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gae5b9be890edb372d3e30a14ce1c79874)
"""
function C_iio_device_buffer_attr_read_longlong(device::Ptr{iio_device}, attr::String)
    value = Ref{Int64}(0);
    ret = ccall(
        (:iio_device_buffer_attr_read_longlong, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Ptr{Clonglong}),
        device, attr, value
    );
    return ret, value[];
end

"""
    C_iio_device_buffer_attr_write(device, attr, value)

Set the value of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::String`           : A NULL-terminated string to set the attribute to

# Returns
- On success, the number of bytes written
- On error, a negative errno code is returned

# NOTE
By passing NULL as the "attr" argument to `iio_device_buffer_attr_write`, it is now possible to write all of the attributes of a device.

The buffer must contain one block of data per attribute of the buffer, by the order they appear in the iio_device structure.

The first four bytes of one block correspond to a 32-bit signed value in network order.
If negative, the attribute is not written;
if positive, it corresponds to the length of the data to write. In that case, the rest of the block must contain the data.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga8a12066003b7ef442e95bfbc22b4370b)
"""
function C_iio_device_buffer_attr_write(device::Ptr{iio_device}, attr::String, value::String)
    return ccall(
        (:iio_device_buffer_attr_write, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Cstring),
        device, attr, value
    );
end

"""
    C_iio_device_buffer_attr_write_all()

THIS IS A PLACEHOLDER. THE DOCUMENTATION BELOW IS ONLY A COPY/PASTE OF THE C DOCUMENTATION.

Set the values of all buffer-specific attributes.

# Parameters
- dev : A pointer to an iio_device structure
- cb : A pointer to a callback function
- data : A pointer that will be passed to the callback function

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

# NOTE
This function is especially useful when used with the network backend, as all the buffer-specific attributes are written in one single command.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga3d77bb90c22eb1d0a13805bf69def068)
"""
function C_iio_device_buffer_attr_write_all()
    return "PLACEHOLDER"
end

"""
    C_iio_device_buffer_attr_write_bool(device, attr, value)

Set the value of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Bool`             : A bool value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga3fad39798014287c24c36bac4a67648e)
"""
function C_iio_device_buffer_attr_write_bool(device::Ptr{iio_device}, attr::String, value::Bool)
    return ccall(
        (:iio_device_buffer_attr_write_bool, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Cuchar),
        device, attr, value
    );
end

"""
    C_iio_device_buffer_attr_write_double(device, attr, value)

Set the value of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Float64`          : A double value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga10d47af8de4ad1f9dc4b63ce0aa0ff7d)
"""
function C_iio_device_buffer_attr_write_double(device::Ptr{iio_device}, attr::String, value::Float64)
    return ccall(
        (:iio_device_buffer_attr_write_double, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Cdouble),
        device, attr, value
    );
end

"""
    C_iio_device_buffer_attr_write_longlong(device, attr, value)

Set the value of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Int64`            : A long long value to set the attribute to

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gac05869aa707121328dd72cdad10cedf2)
"""
function C_iio_device_buffer_attr_write_longlong(device::Ptr{iio_device}, attr::String, value::Int64)
    return ccall(
        (:iio_device_buffer_attr_write_longlong, libIIO),
        Cint, (Ptr{iio_device}, Cstring, Clonglong),
        device, attr, value
    );
end

"""
    C_iio_device_buffer_attr_write_raw(device, attr, value)

Set the value of the given buffer-specific attribute.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `attr::String`            : A NULL-terminated string corresponding to the name of the attribute
- `value::Ptr{Cvoid}`       : A pointer to the data to be written
- `size::Csize_t`           : The number of bytes to be written

# Returns
- On success, the number of bytes written
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga982e2bcb890aab88eabf833a00ba841a)
"""
function C_iio_device_buffer_attr_write_raw(device::Ptr{iio_device}, attr::String, value::Ptr{Cvoid}, size::Csize_t)
    return ccall(
        (:iio_device_buffer_attr_write_raw, libIIO),
        Cssize_t, (Ptr{iio_device}, Cstring, Ptr{Cvoid}, Csize_t),
        device, attr, value, size
    );
end

"""
    C_iio_device_find_attr(device, name)

Try to find a device-specific attribute by its name.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `name::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, a NULL-terminated string.
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns an empty string.

# NOTE
This function is useful to detect the presence of an attribute.
It can also be used to retrieve the name of an attribute as a pointer to a static string from a dynamically allocated string.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gafcbece1ac6260b06bcdf02d9eb55e5fd)
"""
function C_iio_device_find_attr(device::Ptr{iio_device}, name::String)
    @assert_Cstring attr = ccall(
        (:iio_device_find_attr, libIIO),
        Cstring, (Ptr{iio_device}, Cstring),
        device, name
    );
    return attr == C_NULL ? "" : Base.unsafe_string(attr);
end

"""
    C_iio_device_find_buffer_attr(device, name)

Try to find a buffer-specific attribute by its name.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `name::String`            : A NULL-terminated string corresponding to the name of the attribute

# Returns
- On success, a NULL-terminated string.
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns an empty string.

# NOTE
This function is useful to detect the presence of an attribute.
It can also be used to retrieve the name of an attribute as a pointer to a static string from a dynamically allocated string.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga58baa15da06b2d497fb0334f35264240)
"""
function C_iio_device_find_buffer_attr(device::Ptr{iio_device}, name::String)
    @assert_Cstring attr = ccall(
        (:iio_device_find_buffer_attr, libIIO),
        Cstring, (Ptr{iio_device}, Cstring),
        device, name
    );
    return attr == C_NULL ? "" : Base.unsafe_string(attr);
end

"""
    C_iio_device_find_channel(device, name, isOutput)

Try to find a channel structure by its name of ID.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `name::String`            : A NULL-terminated string corresponding to the name or the ID of the channel to search for
- `isOutput::Bool`          : True if the searched channel is output, False otherwise

# Returns
- On success, a pointer to an iio_channel structure
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns NULL.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gaffc6086189ba801ab5e95341d68f882b)
"""
function C_iio_device_find_channel(device::Ptr{iio_device}, name::String, isOutput::Bool)
    @assert_null_pointer channel = ccall(
        (:iio_device_find_channel, libIIO),
        Ptr{iio_channel}, (Ptr{iio_device}, Cstring, Cuchar),
        device, name, isOutput
    );
    return channel;
end

"""
    C_iio_device_get_attr(device, index)

Get the device-specific attribute present at the given index.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `index::UInt32`           : The index corresponding to the attribute

# Returns
- On success, a NULL-terminated string.
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns an empty string.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga70b03d4cb3cc3c4fb1b6451764c8ccec)
"""
function C_iio_device_get_attr(device::Ptr{iio_device}, index::UInt32)
    @assert_Cstring attr = ccall(
        (:iio_device_get_attr, libIIO),
        Cstring, (Ptr{iio_device}, Cuint),
        device, index
    );
    return attr == C_NULL ? "" : Base.unsafe_string(attr);
end

"""
    C_iio_device_get_attrs_count(device)

Enumerate the device-specific attributes of the given device.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- The number of device-specific attributes found

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga36c2d0f703a803f44a578bc83fdab6a0)
"""
function C_iio_device_get_attrs_count(device::Ptr{iio_device})
    return ccall(
        (:iio_device_get_attrs_count, libIIO),
        Cuint, (Ptr{iio_device},),
        device
    );
end

"""
    C_iio_device_get_buffer_attr(device, index)

Get the buffer-specific attribute present at the given index.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `index::UInt32`           : The index corresponding to the attribute

# Returns
- On success, a NULL-terminated string.
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns an empty string.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga7225b9df06559012d549d627fb451c2a)
"""
function C_iio_device_get_buffer_attr(device::Ptr{iio_device}, index::UInt32)
    @assert_Cstring attr = ccall(
        (:iio_device_get_buffer_attr, libIIO),
        Cstring, (Ptr{iio_device}, Cuint),
        device, index
    );
    return attr == C_NULL ? "" : Base.unsafe_string(attr);
end

"""
    C_iio_device_get_buffer_attrs_count(device)

Enumerate the buffer-specific attributes of the given device.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- The number of buffer-specific attributes found

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga6d4bd3c4f9791c706d9baa4454e0f1d3)
"""
function C_iio_device_get_buffer_attrs_count(device::Ptr{iio_device})
    return ccall(
        (:iio_device_get_buffer_attrs_count, libIIO),
        Cuint, (Ptr{iio_device},),
        device
    );
end

"""
    C_iio_device_get_channel(device, index)

Get the channel present at the given index.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `index::UInt32`           : The index corresponding to the channel

# Returns
- On success, a pointer to an iio_channel structure
- On failure, if the assertions are enabled, throws an error.
- On failure, if the assertions are disabled, returns NULL.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga67289d735b7d8e1ed12ae0ea642bd1ac)
"""
function C_iio_device_get_channel(device::Ptr{iio_device}, index::UInt32)
    @assert_null_pointer channel = ccall(
        (:iio_device_get_channel, libIIO),
        Ptr{iio_channel}, (Ptr{iio_device}, Cuint),
        device, index
    );
    return channel;
end

"""
    C_iio_device_get_channels_count(device)

Retrieve a pointer to the iio_context structure.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- A pointer to an iio_context structure

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gae10ff440f64dac52b4229eb3f2ebea76)
"""
function C_iio_device_get_channels_count(device::Ptr{iio_device})
    return ccall(
        (:iio_device_get_channels_count, libIIO),
        Cuint, (Ptr{iio_device},),
        device
    );
end

"""
    C_iio_device_get_context(device)

Retrieve a pointer to the iio_context structure.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- A pointer to an iio_context structure

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gacc7d7b43ca5a1e228ef4c3a4952195fd)
"""
function C_iio_device_get_context(device::Ptr{iio_device})
    return ccall(
        (:iio_device_get_context, libIIO),
        Ptr{iio_context}, (Ptr{iio_device},),
        device
    );
end

"""
    C_iio_device_get_data(device)

Retrieve a previously associated pointer of an iio_device structure.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- The pointer previously associated if present, or NULL

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga87cff8d90e1a68e73410e4a527cc5334)
"""
function C_iio_device_get_data(device::Ptr{iio_device})
    return ccall(
        (:iio_device_get_data, libIIO),
        Ptr{Cvoid}, (Ptr{iio_device},),
        device
    );
end

"""
    C_iio_device_get_id(device)

Retrieve the device ID (e.g. iio:device0)

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- A NULL-terminated string

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga9e6610c3dd7cc45bebcc7ed7a1b064c6)
"""
function C_iio_device_get_id(device::Ptr{iio_device})
    return Base.unsafe_string(ccall(
        (:iio_device_get_id, libIIO),
        Cstring, (Ptr{iio_device},),
        device
    ));
end

"""
    C_iio_device_get_name(device)

Retrieve the device name (e.g. xadc)

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- A NULL-terminated string

# NOTE
If the device has no name and the assertions are enabled, throws an error.
If the device has no name and the assertions are enabled, returns an emtpy string.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga711666b3b3b6314fbe7e592b4632ab85)
"""
function C_iio_device_get_name(device::Ptr{iio_device})
    @assert_Cstring name = ccall(
        (:iio_device_get_name, libIIO),
        Cstring, (Ptr{iio_device},),
        device
    );
    return name == C_NULL ? "" : Base.unsafe_string(name);
end

"""
    C_iio_device_get_trigger(device)

Retrieve the trigger of a given device.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- On success, `(0, trigger::Ptr{iio_device})` is returned.
- On error, `(errno, NULL)` is returned, where errno is a negative error code.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gae3ce1d7385ca02a9f6c36768fa41c610)
"""
function C_iio_device_get_trigger(device::Ptr{iio_device})
    trigger = Ptr{iio_device}();
    ret = ccall(
        (:iio_device_get_trigger, libIIO),
        Cint, (Ptr{iio_device}, Ref{Ptr{iio_device}}),
        device, Ref(trigger)
    );
    return ret, trigger
end

"""
    C_iio_device_is_trigger(device)

Return True if the given device is a trigger.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure

# Returns
- True if the device is a trigger, False otherwise

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga7e3e5dee1ac8c082de038829c88edda8)
"""
function C_iio_device_is_trigger(device::Ptr{iio_device})
    return Base.convert(Bool, ccall(
        (:iio_device_is_trigger, libIIO),
        Cuchar, (Ptr{iio_device},),
        device
    ));
end

"""
    C_iio_device_set_data(device, data)

Associate a pointer to an iio_device structure. If the pointer is a Julia pointer, you need to protect the data from the GC.

See the [Julia Documentation](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/#Garbage-Collection-Safety) and [`GC.@preserve`](https://docs.julialang.org/en/v1/base/base/#Base.GC.@preserve).

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `data::Ptr{Cvoid}`        : A pointer to the data to be associated.

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#gab566248f50503d8975cf258a1f218275)
"""
function C_iio_device_set_data(device::Ptr{iio_device}, data::Ptr{Cvoid})
    ccall(
        (:iio_device_set_data, libIIO),
        Cvoid, (Ptr{iio_device}, Ptr{Cvoid}),
        device, data
    );
end

"""
    C_iio_device_set_kernel_buffers_count(device, nb_buffers)

Configure the number of kernel buffers for a device.

This function allows to change the number of buffers on kernel side.

# Parameters
- `device::Ptr{iio_device}` : A pointer to an iio_device structure
- `nb_buffers::UInt32`      : The number of buffers

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga8ad2357c4caf7afc778060a08e6e2209)
"""
function C_iio_device_set_kernel_buffers_count(device::Ptr{iio_device}, nb_buffers::UInt32)
    return ccall(
        (:iio_device_set_kernel_buffers_count, libIIO),
        Cint, (Ptr{iio_device}, Cuint),
        device, nb_buffers
    );
end

"""
    C_iio_device_set_trigger(device, trigger)

Associate a trigger to a given device.

# Parameters
- `device::Ptr{iio_device}`  : A pointer to an iio_device structure
- `trigger::Ptr{iio_device}` : a pointer to the iio_device structure corresponding to the trigger that should be associated.

# Returns
- On success, 0 is returned
- On error, a negative errno code is returned

[libIIO documentation](https://analogdevicesinc.github.io/libiio/master/libiio/group__Device.html#ga3b8d1e621357f0755925d98555f53d9a)
"""
function C_iio_device_set_trigger(device::Ptr{iio_device}, trigger::Ptr{iio_device})
    return ccall(
        (:iio_device_set_trigger, libIIO),
        Cint, (Ptr{iio_device}, Ptr{iio_device}),
        device, trigger
    );
end


text:
using DataDeps

register(DataDep(
  "wall-following-robot-navigation-2",
  "http://archive.ics.uci.edu/ml/datasets/Wall-Following+Robot+Navigation+Data",
  "http://archive.ics.uci.edu/ml/machine-learning-databases/00194/sensor_readings_2.data",
  "901f0027c108917e47ee4e67beda95d6e81b598646c05383816db6905915983d",
  post_fetch_method=(path -> begin
    UCIData.process_dataset(path,
        target_index=3,
        feature_indices=1:2,
    )
  end),
))

max_stars_repo_name: JackDunnNZ/uci-data

max_issues_repo_name: JackDunnNZ/uci-data

max_forks_repo_name: JackDunnNZ/uci-data


text:
module FoldsCUDA

export CUDAEx, CoalescedCUDAEx, foldx_cuda, transduce_cuda

using CUDA
using CUDA: @allowscalar
using Core: Typeof
using Core.Compiler: return_type
using InitialValues: InitialValue, asmonoid
using UnionArrays: UnionArrays, UnionVector
using Transducers:
    @return_if_reduced,
    Executor,
    Map,
    Reduced,
    Transducer,
    Transducers,
    combine,
    complete,
    next,
    opcompose,
    reduced,
    start,
    transduce,
    unreduced

# TODO: Don't import internals from Transducers:
using Transducers:
    AbstractReduction,
    DefaultInit,
    DefaultInitOf,
    EmptyResultError,
    IdentityTransducer,
    Reduction,
    _reducingfunction,
    extract_transducer,
    foldl_nocomplete

include("utils.jl")
include("kernels.jl")
include("unionvalues.jl")
include("shfl.jl")
include("api.jl")

# Use README as the docstring of the module:
@doc let path = joinpath(dirname(@__DIR__), "README.md")
    include_dependency(path)
    doc = read(path, String)
    doc = replace(doc, r"^```julia"m => "```jldoctest README")
    doc = replace(doc, "(https://juliafolds.github.io/FoldsCUDA.jl/dev/examples/)" => "(@ref examples-toc)")
    doc
end FoldsCUDA

end


text:
function read_from_file(vocab_path::AbstractString, min_freq::Int64=0, stopwords::Set{AbstractString}=Set{AbstractString}();
		regex::Regex=r"")
	fin = open(vocab_path)
	freqs = Array(Int64, 0)
	id2word = Array(AbstractString, 0)
	while !eof(fin)
		try
			word, freq = split(readline(fin))
			freq_num = parse(Int64, freq)
			if freq_num < min_freq || word in stopwords || !ismatch(regex, word) continue end
			push!(id2word, word)
			push!(freqs, freq_num)
		catch e
		end
	end
	close(fin)

	return freqs, id2word
end

function read_from_file(vocab_path::AbstractString, M::Int, T::Int, min_freq::Int=5,
	removeTopK::Int=70, stopwords::Set{AbstractString}=Set{AbstractString}();
	regex::Regex=r"")
	freqs, id2word = read_from_file(vocab_path, min_freq, stopwords; regex=regex)

	S = sortperm(freqs, rev=true)
	freqs = freqs[S[removeTopK+1:end]]
	id2word = id2word[S[removeTopK+1:end]]

	return VectorModel(freqs, M, T), Dictionary(id2word)
end

function build_from_file(text_path::AbstractString, M::Int, T::Int, min_freq::Int64=5)
	f = open(text_path)
	freqs, id2word = count_words(f)
	close(f)

	return VectorModel(freqs, M, T), Dictionary(id2word)
end

function dict_from_file(vocab_path::AbstractString)
	freqs, id2word = read_from_file(vocab_path)

	return Dictionary(id2word)
end

function read_word2vec(path::AbstractString)
	fin = open(path)

	line = readline(fin)
	line = split(line)

	V = parse(Int64, line[1])
	M = parse(Int64, line[2])

	In = zeros(Float32, M, V)
	id2word = Array(AbstractString, 0)

	for v in 1:V
		word = readuntil(fin, ' ')[1:end-1]
		push!(id2word, word)

		In[:, v] = read(fin, Float32, (M))
		readuntil(fin, '\n')
	end

	close(fin)

	return In, Dictionary(id2word)
end

function write_word2vec(path::AbstractString, vm::VectorModel, dict::Dictionary)
	fout = open(path, "w")
	write(fout, "$(V(vm)) $(M(vm))\n")
	for v in 1:V(vm)
		write(fout, "$(dict.id2word[v]) ")
		for i in 1:M(vm)
			write(fout, vm.In[i, 1, v])
		end
		write(fout, "\n")
	end
	close(fout)
end

function finalize!(vm::VectorModel)
	vm.frequencies = sdata(vm.frequencies)
	vm.In = sdata(vm.In)
	vm.Out = sdata(vm.Out)
	vm.counts = sdata(vm.counts)
	vm.code = sdata(vm.code)
	vm.path = sdata(vm.path)
end

function save_model(path::AbstractString, vm::VectorModel, dict::Dictionary, min_prob=1e-5)
	file = open(path, "w")
	println(file, V(vm), " ", M(vm), " ", T(vm))
	println(file, vm.alpha, " ", vm.d)
	println(file, size(vm.code, 1))

	write(file, vm.frequencies)
	write(file, vm.code)
	write(file, vm.path)
	write(file, vm.counts)
	write(file, vm.Out)

	z = zeros(T(vm))

	for v in 1:V(vm)
		nsenses = expected_pi!(z, vm, v, min_prob)
		println(file, dict.id2word[v])
		println(file, nsenses)
		for k in 1:T(vm)
			if z[k] < min_prob continue end
			println(file, k)
			write(file, view(vm.In, :, k, v))
			println(file)
		end
	end

	close(file)
end

function load_model(path::AbstractString)
	file = open(path)

	_V, _M, _T = map(x -> parse(Int, x), split(readline(file)))
	alpha, d = map(x -> parse(Float64, x) , split(readline(file)))
	max_length = parse(Int, readline(file))

	vm = VectorModel(max_length, _V, _M, _T, alpha, d)
	read!(file, sdata(vm.frequencies))
	read!(file, sdata(vm.code))
	read!(file, sdata(vm.path))
	read!(file, sdata(vm.counts))
	read!(file, sdata(vm.Out))

	buffer = zeros(Float32, M(vm))

	id2word = Array(AbstractString, 0)
	for v in 1:V(vm)
		word = strip(readline(file))
		nsenses = parse(Int, readline(file))
		push!(id2word, word)

		for r in 1:nsenses
			k = parse(Int, readline(file))
			read!(file, buffer)
			vm.In[:, k, v] = buffer
			readline(file)
		end
	end

	close(file)

	return vm, Dictionary(id2word)
end

function preprocess(vm::VectorModel, doc::Array{Int32}; min_freq::Int64=5,
	subsampling_treshold::Float64 = 1e-5)
	data = Array(Int32, 0)
	total_freq = sum(vm.frequencies)

	for i in 1:length(doc)
		assert(1 <= doc[i] <= length(vm.frequencies))
		if vm.frequencies[doc[i]] < min_freq
			continue
		end

		if rand() < 1. - sqrt(subsampling_treshold / (vm.frequencies[doc[i]] / total_freq))
			continue
		end

		push!(data, doc[i])
	end

	return data
end

function vec(vm::VectorModel, v::Integer, s::Integer)
	x = vm.In[:, s, v]
	return x / norm(x)
end

function vec(vm::VectorModel, dict::Dictionary, w::AbstractString, s::Integer)
	return vec(vm, dict.word2id[w], s)
end

function nearest_neighbors(vm::VectorModel, dict::Dictionary, word::DenseArray{Tsf},
		K::Integer=10; exclude::Array{Tuple{Int32, Int64}}=Array(Tuple{Int32, Int64}, 0),
		min_count::Float64=1.)
	sim = zeros(Tsf, (T(vm), V(vm)))

	for v in 1:V(vm)
		for s in 1:T(vm)
			if vm.counts[s, v] < min_count
				sim[s, v] = -Inf
				continue
			end
			in_vs = view(vm.In, :, s, v)
			sim[s, v] = dot(in_vs, word) / norm(in_vs)
		end
	end
	for (v, s) in exclude
		sim[s, v] = -Inf
	end
	top = Array(Tuple{Int, Int}, K)
	topSim = zeros(Tsf, K)

	function split_index(sim, i)
		i -= 1
		v = i % size(sim, 1) + 1
		s = Int(floor(i / size(sim, 1))) + 1
		return v, s
	end
	for k in 1:K
		curr_max = split_index(sim, indmax(sim))
		topSim[k] = sim[curr_max[1], curr_max[2]]
		sim[curr_max[1], curr_max[2]] = -Inf

		top[k] = curr_max
	end
	return Tuple{AbstractString, Int, Tsf}[(dict.id2word[r[2]], r[1], simr)
		for (r, simr) in zip(top, topSim)]
end

function nearest_neighbors(vm::VectorModel, dict::Dictionary,
		w::AbstractString, s::Int, K::Integer=10)
	v = dict.word2id[w]
	return nearest_neighbors(vm, dict, vec(vm, v, s), K; exclude=[(v, s)])
end

cos_dist(x, y) = 1. - dot(x, y) / norm(x, 2) / norm(y, 2)

function disambiguate{Tw <: Integer}(vm::VectorModel, x::Tw,
		context::AbstractArray{Tw, 1}, use_prior::Bool=true,
		min_prob::Float64=1e-3)
	z = zeros(T(vm))

	if use_prior
		expected_pi!(z, vm, x)
		for k in 1:T(vm)
			if z[k] < min_prob
				z[k] = 0.
			end
			z[k] = log(z[k])
		end
	end
	for y in context
		var_update_z!(vm, x, y, z)
	end

	exp_normalize!(z)

	return z
end

function disambiguate{Ts <: AbstractString}(vm::VectorModel, dict::Dictionary, x::AbstractString, context::AbstractArray{Ts, 1}, use_prior::Bool=true, min_prob::Float64=1e-3)
	return disambiguate(vm, dict.word2id[x], Int32[dict.word2id[y] for y in context], use_prior, min_prob)
end

export nearest_neighbors
export disambiguate
export pi, write_extended
export cos_dist, preprocess, read_word2vec, write_word2vec

max_stars_repo_name: glicerico/AdaGram

max_issues_repo_name: glicerico/AdaGram

max_forks_repo_name: glicerico/AdaGram