text:
require 'json'
require 'dry-types'
require 'dry-struct'

module Types
  include Dry::Types.module

  Int    = Strict::Int
  Nil    = Strict::Nil
  Bool   = Strict::Bool
  Hash   = Strict::Hash
  String = Strict::String
end

# Information about an operation associated with the log entry, if applicable.
class Operation < Dry::Struct

  # True if this is the first log entry in the operation.
  attribute :first, Types::Bool.optional

  # An arbitrary operation identifier. Log entries with the same
  # identifier are assumed to be part of the same operation.
  attribute :id, Types::String.optional

  # True if this is the last log entry in the operation.
  attribute :last, Types::Bool.optional

  # An arbitrary producer identifier. The combination of `id` and
  # `producer` must be globally unique. Examples for `producer`:
  # `"MyDivision.MyBigCompany.com"`, `"github.com/MyProject/MyApplication"`.
  attribute :producer, Types::String.optional
end

# Metadata about the service that uses the service account.
class ServiceMetadata < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# First party (Google) identity as the real authority.
class FirstPartyPrincipal < Dry::Struct

  # The email address of a Google account.
  attribute :principal_email, Types::String.optional

  # Metadata about the service that uses the service account.
  attribute :service_metadata, ServiceMetadata.optional
end

# Metadata about third party identity.
class ThirdPartyClaims < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# Third party identity as the real authority.
class ServiceAccountDelegationInfoThirdPartyPrincipal < Dry::Struct

  # Metadata about third party identity.
  attribute :third_party_claims, ThirdPartyClaims.optional
end

# Identity delegation history of an authenticated service account.
class ServiceAccountDelegationInfo < Dry::Struct

  # First party (Google) identity as the real authority.
  attribute :first_party_principal, FirstPartyPrincipal.optional

  # Third party identity as the real authority.
  attribute :third_party_principal, ServiceAccountDelegationInfoThirdPartyPrincipal.optional
end

# The third party identification (if any) of the authenticated user making
# the request.
# When the JSON object represented here has a proto equivalent, the proto
# name will be indicated in the `@type` property.
class AuthenticationInfoThirdPartyPrincipal < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# Authentication information.
class AuthenticationInfo < Dry::Struct

  # The authority selector specified by the requestor, if any.
  # It is not guaranteed that the principal was allowed to use this authority.
  attribute :authority_selector, Types::String.optional

  # The email address of the authenticated user (or service account on behalf
  # of third party principal) making the request. For privacy reasons, the
  # principal email address is redacted for all read-only operations that fail
  # with a "permission denied" error.
  attribute :principal_email, Types::String.optional

  # String representation of identity of requesting party.
  # Populated for both first and third party identities.
  attribute :principal_subject, Types::String.optional

  # Identity delegation history of an authenticated service account that makes
  # the request. It contains information on the real authorities that try to
  # access GCP resources by delegating on a service account. When multiple
  # authorities present, they are guaranteed to be sorted based on the original
  # ordering of the identity delegation events.
  attribute :service_account_delegation_info, Types.Array(ServiceAccountDelegationInfo).optional

  # The name of the service account key used to create or exchange
  # credentials for authenticating the service account making the request.
  # This is a scheme-less URI full resource name. For example:
  #
  # "//iam.googleapis.com/projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}/keys/{key}"
  attribute :service_account_key_name, Types::String.optional

  # The third party identification (if any) of the authenticated user making
  # the request.
  # When the JSON object represented here has a proto equivalent, the proto
  # name will be indicated in the `@type` property.
  attribute :third_party_principal, AuthenticationInfoThirdPartyPrincipal.optional
end

# Resource attributes used in IAM condition evaluation. This field contains
# resource attributes like resource type and resource name.
#
# To get the whole view of the attributes used in IAM
# condition evaluation, the user must also look into
# `AuditLogData.request_metadata.request_attributes`.
class ResourceAttributes < Dry::Struct

  # The labels or tags on the resource, such as AWS resource tags and
  # Kubernetes resource labels.
  attribute :labels, Types::Hash.meta(of: Types::String).optional

  # The stable identifier (name) of a resource on the `service`. A resource
  # can be logically identified as "//{resource.service}/{resource.name}".
  # The differences between a resource name and a URI are:
  #
  # *   Resource name is a logical identifier, independent of network
  # protocol and API version. For example,
  # `//pubsub.googleapis.com/projects/123/topics/news-feed`.
  # *   URI often includes protocol and version information, so it can
  # be used directly by applications. For example,
  # `https://pubsub.googleapis.com/v1/projects/123/topics/news-feed`.
  #
  # See https://cloud.google.com/apis/design/resource_names for details.
  attribute :resource_attributes_name, Types::String.optional

  # The name of the service that this resource belongs to, such as
  # `pubsub.googleapis.com`. The service may be different from the DNS
  # hostname that actually serves the request.
  attribute :service, Types::String.optional

  # The type of the resource. The syntax is platform-specific because
  # different platforms define their resources differently.
  #
  # For Google APIs, the type format must be "{service}/{kind}".
  attribute :resource_attributes_type, Types::String.optional
end

# Authorization information for the operation.
class AuthorizationInfo < Dry::Struct

  # Whether or not authorization for `resource` and `permission`
  # was granted.
  attribute :granted, Types::Bool.optional

  # The required IAM permission.
  attribute :permission, Types::String.optional

  # The resource being accessed, as a REST-style string. For example:
  #
  # bigquery.googleapis.com/projects/PROJECTID/datasets/DATASETID
  attribute :resource, Types::String.optional

  # Resource attributes used in IAM condition evaluation. This field contains
  # resource attributes like resource type and resource name.
  #
  # To get the whole view of the attributes used in IAM
  # condition evaluation, the user must also look into
  # `AuditLogData.request_metadata.request_attributes`.
  attribute :resource_attributes, ResourceAttributes.optional
end

# Other service-specific data about the request, response, and other
# information associated with the current audited event.
class Metadata < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

class NumResponseItems < Dry::Struct
  attribute :integer, Types::Int.optional
  attribute :string,  Types::String.optional
end

# The operation request. This may not include all request parameters,
# such as those that are too large, privacy-sensitive, or duplicated
# elsewhere in the log record.
# It should never include user-generated data, such as file contents.
# When the JSON object represented here has a proto equivalent, the proto
# name will be indicated in the `@type` property.
class Request < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# The destination of a network activity, such as accepting a TCP connection.
# In a multi hop network activity, the destination represents the receiver of
# the last hop. Only two fields are used in this message, Peer.port and
# Peer.ip. These fields are optionally populated by those services utilizing
# the IAM condition feature.
class DestinationAttributes < Dry::Struct

  # The IP address of the peer.
  attribute :ip, Types::String.optional

  # The labels associated with the peer.
  attribute :labels, Types::Hash.meta(of: Types::String).optional

  # The network port of the peer.
  attribute :port, Types.Instance(NumResponseItems).optional

  # The identity of this peer. Similar to `Request.auth.principal`, but
  # relative to the peer instead of the request. For example, the
  # idenity associated with a load balancer that forwared the request.
  attribute :principal, Types::String.optional

  # The CLDR country/region code associated with the above IP address.
  # If the IP address is private, the `region_code` should reflect the
  # physical location where this peer is running.
  attribute :region_code, Types::String.optional
end

# Structured claims presented with the credential. JWTs include
# `{key: value}` pairs for standard and private claims. The following
# is a subset of the standard required and optional claims that would
# typically be presented for a Google-based JWT:
#
# {'iss': 'accounts.google.com',
# 'sub': '113289723416554971153',
# 'aud': ['123456789012', 'pubsub.googleapis.com'],
# 'azp': '123456789012.apps.googleusercontent.com',
# 'email': 'jsmith@example.com',
# 'iat': 1353601026,
# 'exp': 1353604926}
#
# SAML assertions are similarly specified, but with an identity provider
# dependent structure.
class Claims < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# The request authentication. May be absent for unauthenticated requests.
# Derived from the HTTP request `Authorization` header or equivalent.
class Auth < Dry::Struct

  # A list of access level resource names that allow resources to be
  # accessed by authenticated requester. It is part of Secure GCP processing
  # for the incoming request. An access level string has the format:
  # "//{api_service_name}/accessPolicies/{policy_id}/accessLevels/{short_name}"
  #
  # Example:
  # "//accesscontextmanager.googleapis.com/accessPolicies/MY_POLICY_ID/accessLevels/MY_LEVEL"
  attribute :access_levels, Types.Array(Types::String).optional

  # The intended audience(s) for this authentication information. Reflects
  # the audience (`aud`) claim within a JWT. The audience
  # value(s) depends on the `issuer`, but typically include one or more of
  # the following pieces of information:
  #
  # *  The services intended to receive the credential such as
  # ["pubsub.googleapis.com", "storage.googleapis.com"]
  # *  A set of service-based scopes. For example,
  # ["https://www.googleapis.com/auth/cloud-platform"]
  # *  The client id of an app, such as the Firebase project id for JWTs
  # from Firebase Auth.
  #
  # Consult the documentation for the credential issuer to determine the
  # information provided.
  attribute :audiences, Types.Array(Types::String).optional

  # Structured claims presented with the credential. JWTs include
  # `{key: value}` pairs for standard and private claims. The following
  # is a subset of the standard required and optional claims that would
  # typically be presented for a Google-based JWT:
  #
  # {'iss': 'accounts.google.com',
  # 'sub': '113289723416554971153',
  # 'aud': ['123456789012', 'pubsub.googleapis.com'],
  # 'azp': '123456789012.apps.googleusercontent.com',
  # 'email': 'jsmith@example.com',
  # 'iat': 1353601026,
  # 'exp': 1353604926}
  #
  # SAML assertions are similarly specified, but with an identity provider
  # dependent structure.
  attribute :claims, Claims.optional

  # The authorized presenter of the credential. Reflects the optional
  # Authorized Presenter (`azp`) claim within a JWT or the
  # OAuth client id. For example, a Google Cloud Platform client id looks
  # as follows: "123456789012.apps.googleusercontent.com".
  attribute :presenter, Types::String.optional

  # The authenticated principal. Reflects the issuer (`iss`) and subject
  # (`sub`) claims within a JWT. The issuer and subject should be `/`
  # delimited, with `/` percent-encoded within the subject fragment. For
  # Google accounts, the principal format is:
  # "https://accounts.google.com/{id}"
  attribute :principal, Types::String.optional
end

# Request attributes used in IAM condition evaluation. This field contains
# request attributes like request time and access levels associated with
# the request.
#
#
# To get the whole view of the attributes used in IAM
# condition evaluation, the user must also look into
# `AuditLog.authentication_info.resource_attributes`.
class RequestAttributes < Dry::Struct

  # The request authentication. May be absent for unauthenticated requests.
  # Derived from the HTTP request `Authorization` header or equivalent.
  attribute :auth, Auth.optional

  # The HTTP request headers. If multiple headers share the same key, they
  # must be merged according to the HTTP spec. All header keys must be
  # lowercased, because HTTP header keys are case-insensitive.
  attribute :headers, Types::Hash.meta(of: Types::String).optional

  # The HTTP request `Host` header value.
  attribute :host, Types::String.optional

  # The unique ID for a request, which can be propagated to downstream
  # systems. The ID should have low probability of collision
  # within a single day for a specific service.
  attribute :id, Types::String.optional

  # The HTTP request method, such as `GET`, `POST`.
  attribute :request_attributes_method, Types::String.optional

  # The HTTP URL path.
  attribute :path, Types::String.optional

  # The network protocol used with the request, such as "http/1.1",
  # "spdy/3", "h2", "h2c", "webrtc", "tcp", "udp", "quic". See
  #
  # https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
  # for details.
  attribute :protocol, Types::String.optional

  # The HTTP URL query in the format of `name1=value1&name2=value2`, as it
  # appears in the first line of the HTTP request. No decoding is performed.
  attribute :query, Types::String.optional

  # A special parameter for request reason. It is used by security systems
  # to associate auditing information with a request.
  attribute :reason, Types::String.optional

  # The HTTP URL scheme, such as `http` and `https`.
  attribute :scheme, Types::String.optional

  # The HTTP request size in bytes. If unknown, it must be -1.
  attribute :size, Types.Instance(NumResponseItems).optional

  # The timestamp when the `destination` service receives the first byte of
  # the request.
  attribute :time, Types::String.optional
end

# Metadata about the operation.
class RequestMetadata < Dry::Struct

  # The IP address of the caller.
  # For caller from internet, this will be public IPv4 or IPv6 address.
  # For caller from a Compute Engine VM with external IP address, this
  # will be the VM's external IP address. For caller from a Compute
  # Engine VM without external IP address, if the VM is in the same
  # organization (or project) as the accessed resource, `caller_ip` will
  # be the VM's internal IPv4 address, otherwise the `caller_ip` will be
  # redacted to "gce-internal-ip".
  # See https://cloud.google.com/compute/docs/vpc/ for more information.
  attribute :caller_ip, Types::String.optional

  # The network of the caller.
  # Set only if the network host project is part of the same GCP organization
  # (or project) as the accessed resource.
  # See https://cloud.google.com/compute/docs/vpc/ for more information.
  # This is a scheme-less URI full resource name. For example:
  #
  # "//compute.googleapis.com/projects/PROJECT_ID/global/networks/NETWORK_ID"
  attribute :caller_network, Types::String.optional

  # The user agent of the caller.
  # This information is not authenticated and should be treated accordingly.
  # For example:
  #
  # +   `google-api-python-client/1.4.0`:
  # The request was made by the Google API client for Python.
  # +   `Cloud SDK Command Line Tool apitools-client/1.0 gcloud/0.9.62`:
  # The request was made by the Google Cloud SDK CLI (gcloud).
  # +   `AppEngine-Google; (+http://code.google.com/appengine; appid:
  # s~my-project`:
  # The request was made from the `my-project` App Engine app.
  attribute :caller_supplied_user_agent, Types::String.optional

  # The destination of a network activity, such as accepting a TCP connection.
  # In a multi hop network activity, the destination represents the receiver of
  # the last hop. Only two fields are used in this message, Peer.port and
  # Peer.ip. These fields are optionally populated by those services utilizing
  # the IAM condition feature.
  attribute :destination_attributes, DestinationAttributes.optional

  # Request attributes used in IAM condition evaluation. This field contains
  # request attributes like request time and access levels associated with
  # the request.
  #
  #
  # To get the whole view of the attributes used in IAM
  # condition evaluation, the user must also look into
  # `AuditLog.authentication_info.resource_attributes`.
  attribute :request_attributes, RequestAttributes.optional
end

# The resource location information.
class ResourceLocation < Dry::Struct

  # The locations of a resource after the execution of the operation.
  # Requests to create or delete a location based resource must populate
  # the 'current_locations' field and not the 'original_locations' field.
  # For example:
  #
  # "europe-west1-a"
  # "us-east1"
  # "nam3"
  attribute :current_locations, Types.Array(Types::String).optional

  # The locations of a resource prior to the execution of the operation.
  # Requests that mutate the resource's location must populate both the
  # 'original_locations' as well as the 'current_locations' fields.
  # For example:
  #
  # "europe-west1-a"
  # "us-east1"
  # "nam3"
  attribute :original_locations, Types.Array(Types::String).optional
end

# The resource's original state before mutation. Present only for
# operations which have successfully modified the targeted resource(s).
# In general, this field should contain all changed fields, except those
# that are already been included in `request`, `response`, `metadata` or
# `service_data` fields.
# When the JSON object represented here has a proto equivalent,
# the proto name will be indicated in the `@type` property.
class ResourceOriginalState < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# The operation response. This may not include all response elements,
# such as those that are too large, privacy-sensitive, or duplicated
# elsewhere in the log record.
# It should never include user-generated data, such as file contents.
# When the JSON object represented here has a proto equivalent, the proto
# name will be indicated in the `@type` property.
class Response < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# Deprecated, use `metadata` field instead.
# Other service-specific data about the request, response, and other
# activities.
# When the JSON object represented here has a proto equivalent, the proto
# name will be indicated in the `@type` property.
class ServiceData < Dry::Struct

  # Unordered map of dynamically typed values.
  attribute :fields, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any).optional).optional
end

# `Any` contains an arbitrary serialized protocol buffer message along with a
# URL that describes the type of the serialized message.
#
# Protobuf library provides support to pack/unpack Any values in the form
# of utility functions or additional generated methods of the Any type.
#
# Example 1: Pack and unpack a message in C++.
#
# Foo foo = ...;
# Any any;
# any.PackFrom(foo);
# ...
# if (any.UnpackTo(&foo)) {
# ...
# }
#
# Example 2: Pack and unpack a message in Java.
#
# Foo foo = ...;
# Any any = Any.pack(foo);
# ...
# if (any.is(Foo.class)) {
# foo = any.unpack(Foo.class);
# }
#
# Example 3: Pack and unpack a message in Python.
#
# foo = Foo(...)
# any = Any()
# any.Pack(foo)
# ...
# if any.Is(Foo.DESCRIPTOR):
# any.Unpack(foo)
# ...
#
# Example 4: Pack and unpack a message in Go
#
# foo := &pb.Foo{...}
# any, err := ptypes.MarshalAny(foo)
# ...
# foo := &pb.Foo{}
# if err := ptypes.UnmarshalAny(any, foo); err != nil {
# ...
# }
#
# The pack methods provided by protobuf library will by default use
# 'type.googleapis.com/full.type.name' as the type URL and the unpack
# methods only use the fully qualified type name after the last '/'
# in the type URL, for example "foo.bar.com/x/y.z" will yield type
# name "y.z".
#
#
# JSON
# ====
# The JSON representation of an `Any` value uses the regular
# representation of the deserialized, embedded message, with an
# additional field `@type` which contains the type URL. Example:
#
# package google.profile;
# message Person {
# string first_name = 1;
# string last_name = 2;
# }
#
# {
# "@type": "type.googleapis.com/google.profile.Person",
# "firstName": <string>,
# "lastName": <string>
# }
#
# If the embedded message type is well-known and has a custom JSON
# representation, that representation will be embedded adding a field
# `value` which holds the custom JSON in addition to the `@type`
# field. Example (for message [google.protobuf.Duration][]):
#
# {
# "@type": "type.googleapis.com/google.protobuf.Duration",
# "value": "1.212s"
# }
class Detail < Dry::Struct

  # A URL/resource name that uniquely identifies the type of the serialized
  # protocol buffer message. This string must contain at least
  # one "/" character. The last segment of the URL's path must represent
  # the fully qualified name of the type (as in
  # `path/google.protobuf.Duration`). The name should be in a canonical form
  # (e.g., leading "." is not accepted).
  #
  # In practice, teams usually precompile into the binary all types that they
  # expect it to use in the context of Any. However, for URLs which use the
  # scheme `http`, `https`, or no scheme, one can optionally set up a type
  # server that maps type URLs to message definitions as follows:
  #
  # * If no scheme is provided, `https` is assumed.
  # * An HTTP GET on the URL must yield a [google.protobuf.Type][]
  # value in binary format, or produce an error.
  # * Applications are allowed to cache lookup results based on the
  # URL, or have them precompiled into a binary to avoid any
  # lookup. Therefore, binary compatibility needs to be preserved
  # on changes to types. (Use versioned type names to manage
  # breaking changes.)
  #
  # Note: this functionality is not currently available in the official
  # protobuf release, and it is not used for type URLs beginning with
  # type.googleapis.com.
  #
  # Schemes other than `http`, `https` (or the empty scheme) might be
  # used with implementation specific semantics.
  attribute :type_url, Types::String.optional

  # Must be a valid serialized protocol buffer of the above specified type.
  attribute :value, Types::String.optional
end

# The status of the overall operation.
class Status < Dry::Struct

  # The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
  attribute :code, Types::Int.optional

  # A list of messages that carry the error details.  There is a common set of
  # message types for APIs to use.
  attribute :details, Types.Array(Detail).optional

  # A developer-facing error message, which should be in English. Any
  # user-facing error message should be localized and sent in the
  # [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
  attribute :message, Types::String.optional
end

# The log entry payload, which is always an AuditLog for Cloud Audit Log events.
class ProtoPayload < Dry::Struct

  # Authentication information.
  attribute :authentication_info, AuthenticationInfo.optional

  # Authorization information. If there are multiple
  # resources or permissions involved, then there is
  # one AuthorizationInfo element for each {resource, permission} tuple.
  attribute :authorization_info, Types.Array(AuthorizationInfo).optional

  # Other service-specific data about the request, response, and other
  # information associated with the current audited event.
  attribute :metadata, Metadata.optional

  # The name of the service method or operation.
  # For API calls, this should be the name of the API method.
  # For example,
  #
  # "google.datastore.v1.Datastore.RunQuery"
  # "google.logging.v1.LoggingService.DeleteLog"
  attribute :method_name, Types::String.optional

  # The number of items returned from a List or Query API method,
  # if applicable.
  attribute :num_response_items, Types.Instance(NumResponseItems).optional

  # The operation request. This may not include all request parameters,
  # such as those that are too large, privacy-sensitive, or duplicated
  # elsewhere in the log record.
  # It should never include user-generated data, such as file contents.
  # When the JSON object represented here has a proto equivalent, the proto
  # name will be indicated in the `@type` property.
  attribute :request, Request.optional

  # Metadata about the operation.
  attribute :request_metadata, RequestMetadata.optional

  # The resource location information.
  attribute :resource_location, ResourceLocation.optional

  # The resource or collection that is the target of the operation.
  # The name is a scheme-less URI, not including the API service name.
  # For example:
  #
  # "shelves/SHELF_ID/books"
  # "shelves/SHELF_ID/books/BOOK_ID"
  attribute :resource_name, Types::String.optional

  # The resource's original state before mutation. Present only for
  # operations which have successfully modified the targeted resource(s).
  # In general, this field should contain all changed fields, except those
  # that are already been included in `request`, `response`, `metadata` or
  # `service_data` fields.
  # When the JSON object represented here has a proto equivalent,
  # the proto name will be indicated in the `@type` property.
  attribute :resource_original_state, ResourceOriginalState.optional

  # The operation response. This may not include all response elements,
  # such as those that are too large, privacy-sensitive, or duplicated
  # elsewhere in the log record.
  # It should never include user-generated data, such as file contents.
  # When the JSON object represented here has a proto equivalent, the proto
  # name will be indicated in the `@type` property.
  attribute :response, Response.optional

  # Deprecated, use `metadata` field instead.
  # Other service-specific data about the request, response, and other
  # activities.
  # When the JSON object represented here has a proto equivalent, the proto
  # name will be indicated in the `@type` property.
  attribute :service_data, ServiceData.optional

  # The name of the API service performing the operation. For example,
  # `"datastore.googleapis.com"`.
  attribute :service_name, Types::String.optional

  # The status of the overall operation.
  attribute :status, Status.optional
end

# The monitored resource that produced this log entry.
#
# Example: a log entry that reports a database error would be associated with
# the monitored resource designating the particular database that reported
# the error.
class Resource < Dry::Struct

  # Values for all of the labels listed in the associated monitored
  # resource descriptor. For example, Compute Engine VM instances use the
  # labels `"project_id"`, `"instance_id"`, and `"zone"`.
  attribute :labels, Types::Hash.meta(of: Types::String).optional

  # Required. The monitored resource type. For example, the type of a
  # Compute Engine VM instance is `gce_instance`.
  attribute :resource_type, Types::String.optional
end

# Generic log entry, used as a wrapper for Cloud Audit Logs in events.
# This is copied from
# https://github.com/googleapis/googleapis/blob/master/google/logging/v2/log_entry.proto
# and adapted appropriately.
class LogEntryData < Dry::Struct

  # A unique identifier for the log entry.
  attribute :insert_id, Types::String.optional

  # A set of user-defined (key, value) data that provides additional
  # information about the log entry.
  attribute :labels, Types::Hash.meta(of: Types::String).optional

  # The resource name of the log to which this log entry belongs.
  attribute :log_name, Types::String.optional

  # Information about an operation associated with the log entry, if applicable.
  attribute :operation, Operation.optional

  # The log entry payload, which is always an AuditLog for Cloud Audit Log events.
  attribute :proto_payload, ProtoPayload.optional

  # The time the log entry was received by Logging.
  attribute :receive_timestamp, Types::String.optional

  # The monitored resource that produced this log entry.
  #
  # Example: a log entry that reports a database error would be associated with
  # the monitored resource designating the particular database that reported
  # the error.
  attribute :resource, Resource.optional

  # The severity of the log entry.
  attribute :severity, Types.Instance(NumResponseItems).optional

  # The span ID within the trace associated with the log entry, if any.
  #
  # For Trace spans, this is the same format that the Trace API v2 uses: a
  # 16-character hexadecimal encoding of an 8-byte array, such as
  # `000000000000004a`.
  attribute :span_id, Types::String.optional

  # The time the event described by the log entry occurred.
  attribute :timestamp, Types::String.optional

  # Resource name of the trace associated with the log entry, if any. If it
  # contains a relative resource name, the name is assumed to be relative to
  # `//tracing.googleapis.com`. Example:
  # `projects/my-projectid/traces/06796866738c859f2f19b7cfb3214824`
  attribute :trace, Types::String.optional
end


text:
namespace Es.Logging
{
    /// <summary>
    /// Provider from <see cref="ConsoleLogger"/>
    /// </summary>
    public class ConsoleLoggerProvider : ILoggerProvider
    {
        private readonly LogLevel _minLevel;
        private readonly bool _colorEnable;

        /// <summary>
        /// Constructor parameters setup log to register
        /// </summary>
        /// <param name="minLevel">Setting <see cref="LogLevel"/></param>
        /// <param name="colorEnable">Whether open font color</param>
        public ConsoleLoggerProvider(LogLevel minLevel, bool colorEnable = true)
        {
            _minLevel = minLevel;
            _colorEnable = colorEnable;
        }

        /// <summary>
        /// create a <see cref="ConsoleLogger"/> instance
        /// </summary>
        /// <param name="name"></param>
        /// <returns>return <see cref="ConsoleLogger"/> instance</returns>
        public ILogger CreateLogger(string name)
        {
            return new ConsoleLogger(name, _minLevel) { ColorEnable = _colorEnable };
        }

        /// <summary>
        /// Perform and release or reset unmanaged resources associated application defined tasks.
        /// </summary>
        public void Dispose()
        {
            //nothing
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
/*
 * 2015
 */
package oli.bbp.gfx.gobj;

import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.MultipleGradientPaint.CycleMethod;
import java.awt.RadialGradientPaint;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayDeque;
import java.util.HashMap;
import oli.bbp.DimensionHelper;
import oli.bbp.ScriptReader;
import oli.bbp.ScriptReader.ScriptFormatException;
import oli.bbp.gfx.GfxHelper;
import oli.bbp.gfx.TweenDeclaration;
import oli.bbp.sim.Molecule;
import oli.bbp.sim.Molecule.MolVector2D;
import oli.bbp.sim.MoleculeColourGroup;
import oli.bbp.sim.ParticleSimStateSave;
import oli.bbp.sim.ParticleSimStateSave.HistorySave;
import oli.bbp.sim.ParticleSimStateSave.HistorySave.OldMolecule;
import oli.bbp.sim.ParticleSimulator;
import org.json.JSONArray;
import org.json.JSONObject;

/**
 *
 * @author oliver
 */
public class ParticleSimGobject extends Gobject {

    ParticleSimulator psim;

    /**
     * A queue of (FPS) elements for showing the position of a molecule 1sec ago
     */
    ArrayDeque<ParticleSimStateSave.HistorySave> historyQueue = new ArrayDeque<>();

    boolean showHistory;
    boolean showVectors;

    float historyOpacity;
    float vectorWidth;
    float vectorScalar;

    double simSpeed;
    double accumTicks = 0;

    Color borderCol;
    Color vectorCol;

    String timeMonitor_id;
    TextGobject timeMonitor;
    int timeMonitor_dp;
    double timeMonitor_divisor;

    int historyPeriod;

    public static HashMap<String, MoleculeColourGroup> molcgs = new HashMap<>();

    public ParticleSimGobject(String id, JSONObject jo) {
        super(id, jo);

        showHistory = jo.optBoolean("showHistory", true);
        showVectors = jo.optBoolean("showVectors", false);

        historyOpacity = (float) jo.optDouble("historyOpacity", 0.4);
        vectorWidth = (float) jo.optDouble("drawnVectorWidth", 3.0);
        vectorScalar = (float) jo.optDouble("drawnVectorScalar", 30.0);
        vectorCol = ScriptReader.strToColour(jo.optString("drawnVectorColour", "#ffffff"));

        simSpeed = jo.optDouble("simSpeed", 300.0);

        borderCol = ScriptReader.strToColour(jo.optString("borderColour", "#ffffff"));

        historyPeriod = Math.max(1, DimensionHelper.getFramesFromSeconds(jo.optDouble("historyPeriod", 0.05)));

        if (! jo.has("simulator")) {
            throw new ScriptReader.ScriptFormatException(this, "No simulator parameter passed. Unable to instantiate ParticleSimulator.");
        }

        if (jo.has("colourGroups")) {
            JSONObject cgjo = jo.getJSONObject("colourGroups");
            for (Object keyo : cgjo.keySet().toArray()) {
                String key = (String) keyo;
                JSONArray cgjovja = cgjo.getJSONArray(key);
                molcgs.put(key, new MoleculeColourGroup(
                        ScriptReader.strToColour(cgjovja.getString(0)),
                        ScriptReader.strToColour(cgjovja.getString(1)),
                        ScriptReader.strToColour(cgjovja.getString(2)),
                        ScriptReader.strToColour(cgjovja.getString(3))
                ));
            }
        }

        if (jo.has("timeMonitor")) {
            JSONArray tja = jo.getJSONArray("timeMonitor");
            this.timeMonitor_id = tja.getString(0);

            timeMonitor_dp = tja.optInt(1, 3);
            timeMonitor_divisor = tja.optDouble(2, simSpeed);
        }

        psim = new ParticleSimulator(jo.getJSONObject("simulator"));

    }

    private ParticleSimGobject() {

    }

    @Override
    public void postConstruct() {
        if (this.timeMonitor_id != null) {
            Gobject go = Gobject.getGobjectById(this.timeMonitor_id);
            if (go == null) {
                throw new ScriptFormatException(this, "timeMonitor[0] must be the name of a TextGobject already initialised. Re-order your Gobjects if necessary.");
            }
            if (! (go instanceof TextGobject)) {
                throw new ScriptFormatException(this, "timeMonitor[0] must be the name of a TextGobject. Any old Gobject will not just do.");
            }
            this.timeMonitor = (TextGobject) go;
        }
    }

    @Override
    public void draw(Graphics2D g2d) {
        g2d.setColor(this.borderCol);
        g2d.drawRect(
                DimensionHelper.getRealDimensions(this.bounds.x),
                DimensionHelper.getRealDimensions(this.bounds.y),
                DimensionHelper.getRealDimensions(this.bounds.width),
                DimensionHelper.getRealDimensions(this.bounds.height)
        );

        /* Precision errors mean that they were rounded to 0...
        therefore, will use BigDecimal
        double xMod = this.bounds.width / psim.simWidth;
        double yMod = this.bounds.height / psim.simHeight;
        */

        BigDecimal xMod, yMod;

        try {
            MathContext mc = new MathContext(7, RoundingMode.HALF_UP);
            xMod = new BigDecimal(this.bounds.width).divide(new BigDecimal(psim.simWidth), mc);
            yMod = new BigDecimal(this.bounds.height).divide(new BigDecimal(psim.simHeight), mc);
        } catch (ArithmeticException e) {
            throw e;
        }

        BigDecimal downscale = new BigDecimal(DimensionHelper.CURRENT_DOWNSCALE);

        xMod = xMod.multiply(downscale);
        yMod = yMod.multiply(downscale);

        // get the transformation matrix so we can restore it later
        AffineTransform restoreAT = g2d.getTransform();

        // translate so that 0,0 is 0,0 of the gobject
        g2d.translate(DimensionHelper.getRealDimensions(this.bounds.x), DimensionHelper.getRealDimensions(this.bounds.y));

        // scale so that dimensions match virtual, in-simulator dimensions;
        g2d.scale(xMod.doubleValue(), yMod.doubleValue());

        if (this.showHistory) { // draw history in transparent layer!
            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, this.historyOpacity));

            // get the history for 1 second ago
            HistorySave save;
            if (historyQueue.size() < historyPeriod) {
                save = historyQueue.peekFirst();
            } else {
                save = historyQueue.pollFirst();
            }

            if (save != null) {
                for (int moli = 0; moli < save.oldMols.length; ++moli) {
                    OldMolecule m = save.oldMols[moli];
                    MoleculeColourGroup mcg = molcgs.get(m.colGroup);

                    g2d.setPaint(new RadialGradientPaint(
                            new Point2D.Float(
                                    (float) m.basis.x,
                                    (float) m.basis.y
                            ),
                            m.radius,
                            new Point2D.Float(
                                    (float) m.basis.x + m.radius / 2,
                                    (float) m.basis.y - m.radius / 2
                            ),
                            new float[]{0f, 0.8f, 1f},
                            new Color[]{
                                mcg.history_primary,
                                mcg.history_secondary,
                                mcg.history_secondary,
                            },
                            CycleMethod.NO_CYCLE
                    ));
                    g2d.fillArc(
                            (int) m.basis.x - m.radius,
                            (int) m.basis.y - m.radius,
                            2 * m.radius,
                            2 * m.radius,
                            0, 360
                    );
                }
            }
            // revert to opaque
            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
        }

        for (int moli = 0; moli < psim.mols.length; ++moli) {
            Molecule m = psim.mols[moli];
            MoleculeColourGroup mcg = molcgs.get(m.colGroup);

            g2d.setPaint(new RadialGradientPaint(
                    new Point2D.Float(
                            (float) m.basis.x,
                            (float) m.basis.y
                    ),
                    m.radius,
                    new Point2D.Float(
                            (float) m.basis.x + m.radius / 2,
                            (float) m.basis.y - m.radius / 2
                    ),
                    new float[]{0f, 0.8f, 1f},
                    new Color[]{
                        mcg.active_primary,
                        mcg.active_secondary,
                        mcg.active_secondary,
                    },
                    CycleMethod.NO_CYCLE
            ));
            g2d.fillArc(
                    (int) m.basis.x - m.radius,
                    (int) m.basis.y - m.radius,
                    2 * m.radius,
                    2 * m.radius,
                    0, 360
            );
        }

        if (showVectors) {
            // render momentum vectors
            Stroke restoreStroke = g2d.getStroke();
            g2d.setColor(vectorCol);

            g2d.setStroke(new BasicStroke(vectorWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND));

            for (int moli = 0; moli < psim.mols.length; ++moli) {
                Molecule m = psim.mols[moli];

                // vectors will be rendered as arrows

                if (m.momentum.isNullVector()) continue;

                MolVector2D mv2d = new MolVector2D(m.basis);
                mv2d.add(m.momentum.scale(vectorScalar));

                GfxHelper.drawArrow(
                        g2d,
                        (int) m.basis.x,
                        (int) m.basis.y,
                        (int) mv2d.x,
                        (int) mv2d.y
                );
            }

            g2d.setStroke(restoreStroke);
        }

        // restore the Transformation Matrix
        g2d.setTransform(restoreAT);
    }

    public void common(TweenDeclaration td, int frameNum) {
        this.simSpeed = TweenDeclaration.TweenSimpleHandlers.simpleUpdateField(
                "simSpeed", td, this.simSpeed
        );

        this.vectorWidth = TweenDeclaration.TweenSimpleHandlers.simpleUpdateField(
                "drawnVectorWidth", td, this.vectorWidth
        );

        this.vectorScalar = TweenDeclaration.TweenSimpleHandlers.simpleUpdateField(
                "drawnVectorScalar", td, this.vectorScalar
        );

        this.showVectors = TweenDeclaration.TweenSimpleHandlers.simpleBooleanField(
                "shownVectors", td, this.showVectors
        );
    }

    @Override
    public void tween(TweenDeclaration td, int frameNum) {
        super.tween(td, frameNum);

        common(td, frameNum);

        if (td.affectedProperty.equals("simulate")) {
            // because there may be a decimal result returned,
            // ticks should 'accumulate' so that hopefully the difference
            // is not noticed. This way, simulations will run at the same
            // perceived speed at different framerates.
            accumTicks += simSpeed / DimensionHelper.FRAMES_PER_SECOND;
            historyQueue.addLast(new ParticleSimStateSave.HistorySave(psim));
            while (accumTicks >= 1) {
                accumTicks--;
                psim.update();
            }

            if (this.timeMonitor != null) {
                // update the time monitor
                double timeVal = (double) psim.simTime / timeMonitor_divisor;
                double dpPow = Math.pow(10, timeMonitor_dp);

                double speedVal = this.simSpeed / timeMonitor_divisor;
                double spPow = Math.pow(10, timeMonitor_dp);
                String timeRep = Double.toString(Math.floor(speedVal * spPow) / spPow) + "×, " + Double.toString(Math.floor(timeVal * dpPow) / dpPow);
                this.timeMonitor.text = timeRep;
            }
        }
    }

    @Override
    public void instantChange(TweenDeclaration td, int frameNum) {
        super.instantChange(td, frameNum);

        if ("dupe".equals(td.affectedProperty)) {
            // duplicate this Gobject -- but keep the same ParticleSimulator
            // this allows the showing of multiple viewports, or the fading in and out
            // of vector arrows, etc
            ParticleSimGobject psgo = new ParticleSimGobject();
            psgo.borderCol = this.borderCol;
            psgo.historyOpacity = this.historyOpacity;
            psgo.psim = this.psim;
            psgo.showHistory = this.showHistory;
            psgo.historyPeriod = this.historyPeriod;
            psgo.showVectors = this.showVectors;
            psgo.vectorCol = this.vectorCol;
            psgo.vectorScalar = this.vectorScalar;
            psgo.vectorWidth = this.vectorWidth;
            Gobject go = Gobject.getGobjectById(td.json.getString(0));
            if (! (go instanceof DuplicationDestinationGobject)) {
                throw new ScriptFormatException(this, "Replacee must be of 'dd' type.");
            }
            DuplicationDestinationGobject ddgo = (DuplicationDestinationGobject) go;
            ddgo.supersede(psgo);
        }

        if (td.affectedProperty.equals("reverseVectors")) {
            for (Molecule mol : psim.mols) {
                mol.momentum.reverseX();
                mol.momentum.reverseY();
            }
        }

        if (td.affectedProperty.equals("isimulate")) {
            // an instant simulation
            // if parameter is negative, this is a de-simulation (BROKEN, with NO INTENTION OF A FIX!!)
            int cycles = td.json.getInt(0);
            boolean desim = cycles < 0;

            boolean preserveTime = td.json.getBoolean(1);
            long timePreserve = psim.simTime;

            if (desim) {
                cycles = -cycles;
                for (Molecule mol : psim.mols) {
                    mol.momentum.reverseX();
                    mol.momentum.reverseY();
                }
            }

            for (int i = 0; i < cycles; ++i) {
                psim.update();
            }

            if (preserveTime) {
                psim.simTime = timePreserve;
            }

            if (desim) {
                for (Molecule mol : psim.mols) {
                    mol.momentum.reverseX();
                    mol.momentum.reverseY();
                }
            }
        }

        if (td.affectedProperty.equals("save_pss")) {
            ParticleSimStateSave.savePSim(td.json.getString(0), this.psim);
        }

        if (td.affectedProperty.equals("load_pss")) {
            ParticleSimStateSave.loadPSim(td.json.getString(0), this.psim);
        }

        if (td.affectedProperty.equals("load_exclusive_pss")) {
            this.psim = new ParticleSimulator();
            ParticleSimStateSave.loadPSim(td.json.getString(0), this.psim);
        }

        common(td, frameNum);
    }

}


text:
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import

import os, sys, unittest

# the pyeq2 directory is located up one level from here
if -1 != sys.path[0].find('pyeq2-master'):raise Exception('Please rename git checkout directory from "pyeq2-master" to "pyeq2"')
if os.path.join(sys.path[0][:sys.path[0].rfind(os.sep)], '..') not in sys.path:
    sys.path.append(os.path.join(sys.path[0][:sys.path[0].rfind(os.sep)], '..'))
import pyeq2

import NIST_TestingUtilities

# from http://www.itl.nist.gov/div898/strd/nls/nls_info.shtml
#
# The certified results are reported to 11 decimal places for each dataset.
# Clearly, most of these digits are not statistically significant, and we
# are not advocating that results should be reported to this number of
# digits in a statistical context. We do believe, however, that this
# number of digits can be useful when testing the numerical properties of
# a procedure. Except in cases where the certified value is essentially
# zero (for example, as occurs for the three Lanczos problems), a good
# nonlinear least squares procedure should be able to duplicate the
# certified results to at least 4 or 5 digits.

class Test_NIST(unittest.TestCase):

    def test_NIST_Nelson_3D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Nelson.dat', True)
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_3D.NIST.NIST_Nelson(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_3D.NIST.NIST_Nelson(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Bennett5_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Bennett5.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Bennett5(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Bennett5(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_BoxBOD_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/BoxBOD.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_BoxBOD(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_BoxBOD(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Chwirut1_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Chwirut1.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Chwirut(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Chwirut(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Chwirut2_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Chwirut2.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Chwirut(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Chwirut(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_DanWood_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/DanWood.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_DanWood(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_DanWood(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_ENSO_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/ENSO.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_ENSO(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_ENSO(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Eckerle4_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Eckerle4.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Eckerle4(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Eckerle4(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Gauss1_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Gauss1.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Gauss2_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Gauss2.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Gauss3_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Gauss3.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Gauss(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Hahn_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Hahn1.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Hahn(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Hahn(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Kirby_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Kirby2.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Kirby(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Kirby(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Lanczos1_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Lanczos1.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Lanczos2_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Lanczos2.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Lanczos3_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Lanczos3.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Lanczos(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_MGH09_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/MGH09.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH09(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH09(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_MGH10_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/MGH10.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH10(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH10(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_MGH17_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/MGH17.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH17(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_MGH17(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Misra1a_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Misra1a.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1a(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1a(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Misra1b_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Misra1b.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1b(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1b(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Misra1c_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Misra1c.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1c(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1c(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Misra1d_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Misra1d.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1d(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Misra1d(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Rat42_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Rat42.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Rat42(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Rat42(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Rat43_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Rat43.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Rat43(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Rat43(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Roszman_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Roszman1.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Roszman(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Roszman(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

    def test_NIST_Thurber_2D(self):
        nistDataObject = NIST_TestingUtilities.LoadDataFileFromNIST('NIST_DataFiles/Thurber.dat')
        result1 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Thurber(), nistDataObject, nistDataObject.Start_1_Values, 'Start 1', False)
        result2 = NIST_TestingUtilities.CalculateAndPrintResults(pyeq2.Models_2D.NIST.NIST_Thurber(), nistDataObject, nistDataObject.Start_2_Values, 'Start 2', False)
        self.assertTrue(result1)
        self.assertTrue(result2)

if __name__ == '__main__':
    unittest.main()


text:
@javax.xml.bind.annotation.XmlSchema(namespace = "http://uzh.ch/ddis/katts/query", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)
package ch.uzh.ddis.katts.query.output;


text:
package com.amazonaws.services.athena.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.athena.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * GetPreparedStatementRequestMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class GetPreparedStatementRequestMarshaller {

    private static final MarshallingInfo<String> STATEMENTNAME_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("StatementName").build();
    private static final MarshallingInfo<String> WORKGROUP_BINDING = MarshallingInfo.builder(MarshallingType.STRING).marshallLocation(MarshallLocation.PAYLOAD)
            .marshallLocationName("WorkGroup").build();

    private static final GetPreparedStatementRequestMarshaller instance = new GetPreparedStatementRequestMarshaller();

    public static GetPreparedStatementRequestMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(GetPreparedStatementRequest getPreparedStatementRequest, ProtocolMarshaller protocolMarshaller) {

        if (getPreparedStatementRequest == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(getPreparedStatementRequest.getStatementName(), STATEMENTNAME_BINDING);
            protocolMarshaller.marshall(getPreparedStatementRequest.getWorkGroup(), WORKGROUP_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}