translate

package
v1.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 6, 2026 License: MIT Imports: 24 Imported by: 0

README

Translate

Parity grade: A · SDK aws-sdk-go-v2/service/translate@v1.36.4 · last audited 2026-08-20 (1efb1a758)

Coverage

Metric Value
PARITY entries audited 19 (19 ok)
Feature families 5 (5 ok)
Known gaps 2
Deferred items 0
Resource leaks clean
Known gaps
  • Mock limitation (no real ML/Comprehend): SourceLanguageCode echoes 'auto' when omitted; DetectedLanguageLowConfidence/TooManyRequests/InternalServer/ServiceUnavailable/ConcurrentModification have no backend trigger (injectable via chaos, see test/integration).
  • Inert encryption: EncryptionKey.Type/Id accepted unvalidated (no KMS cross-service check); TerminologyProperties.SkippedTermCount/Message, ParallelDataProperties record counts/Message and TextTranslationJobProperties.JobDetails counts never populated (no S3 document/record reading); ListLanguages LanguageName ignores DisplayLanguageCode (no i18n table). UpdateParallelData.ClientToken is not replayed (the update is naturally idempotent) and GetTerminology.TerminologyDataFormat does not change the fabricated TerminologyDataLocation.

More

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrNotFound is returned when a requested resource is absent. Also used
	// (per the real per-operation error models) for operations whose only
	// modeled client-error exception IS ResourceNotFoundException -- i.e.
	// GetParallelData/DeleteParallelData/StopTextTranslationJob/
	// DescribeTextTranslationJob have no InvalidRequestException or
	// InvalidParameterValueException in their error list at all, so an
	// empty/missing key on those operations must still surface as
	// ResourceNotFoundException, not a validation exception the real
	// operation never throws.
	ErrNotFound = errors.New("ResourceNotFoundException")
	// ErrConflict is returned when a named resource already exists (name
	// conflict on CreateParallelData). Real Amazon Translate has no
	// "ResourceInUseException" shape at all (confirmed: absent from
	// types/errors.go and the smithy model) -- CreateParallelData models
	// ConflictException for exactly this case.
	ErrConflict = errors.New("ConflictException")
	// ErrValidation is returned for invalid/missing request values on
	// operations whose modeled error list includes InvalidRequestException:
	// CreateParallelData, UpdateParallelData, StartTextTranslationJob,
	// ListTextTranslationJobs, TranslateText, TranslateDocument.
	ErrValidation = errors.New("InvalidRequestException")
	// ErrInvalidParameter is returned for invalid/missing request values on
	// operations whose modeled error list includes
	// InvalidParameterValueException but NOT InvalidRequestException:
	// ImportTerminology, GetTerminology, DeleteTerminology,
	// ListTerminologies, GetParallelData, ListParallelData, TagResource,
	// UntagResource, ListTagsForResource, ListLanguages.
	ErrInvalidParameter = errors.New("InvalidParameterValueException")
	// ErrLimitExceeded is returned when a request would exceed a modeled
	// service quota: the 10 MB custom terminology file size limit
	// (ImportTerminology) or the 100,000-byte TranslateDocument document
	// size limit (TranslateDocument), both confirmed against the
	// TerminologyFile/DocumentContent blob shapes' "max" constraints in the
	// smithy model.
	ErrLimitExceeded = errors.New("LimitExceededException")
	// ErrTextSizeLimitExceeded is returned when TranslateText's Text exceeds
	// the 10,000-byte synchronous translation quota (confirmed against
	// BoundedLengthString's "max": 10000 in the smithy model and the Amazon
	// Translate guidelines/quotas page).
	ErrTextSizeLimitExceeded = errors.New("TextSizeLimitExceededException")
	// ErrTooManyTags is returned when a resource would carry more than the
	// 50-tag-per-resource limit (both existing and newly requested tags
	// count), matching TooManyTagsException.
	ErrTooManyTags = errors.New("TooManyTagsException")
	// ErrUnsupportedLanguagePair is returned when TranslateText,
	// TranslateDocument, or StartTextTranslationJob is given a
	// SourceLanguageCode (other than "auto") or target language code not in
	// Translate's supported language list (see handler_languages.go's
	// knownLanguages, the same list ListLanguages serves).
	ErrUnsupportedLanguagePair = errors.New("UnsupportedLanguagePairException")
	// ErrUnsupportedDisplayLanguage is returned when ListLanguages is given
	// a DisplayLanguageCode outside the fixed 10-value enum Translate
	// actually supports for UI localization (de/en/es/fr/it/ja/ko/pt/zh/
	// zh-TW -- confirmed against the DisplayLanguageCode shape's "enum" in
	// the smithy model; this is a much smaller set than the ~75
	// translation-target language codes).
	ErrUnsupportedDisplayLanguage = errors.New("UnsupportedDisplayLanguageCodeException")
	// ErrInvalidFilter is returned when ListTextTranslationJobs is given a
	// Filter.JobStatus value outside the modeled JobStatus enum.
	ErrInvalidFilter = errors.New("InvalidFilterException")
	// ErrConcurrentModification is returned when UpdateParallelData targets a
	// parallel data resource that is still CREATING or UPDATING from a prior
	// call. types/errors.go's ConcurrentModificationException doc: "Another
	// modification is being made. That modification must complete before you
	// can make your change." UpdateParallelData models this exception
	// (deserializers.go's awsAwsjson11_deserializeOpErrorUpdateParallelData).
	ErrConcurrentModification = errors.New("ConcurrentModificationException")
)

Sentinel errors map 1:1 to Translate's modeled exception shapes (aws-sdk-go-v2/service/translate/types/errors.go, confirmed against the smithy model's per-operation error lists in aws-sdk-go@v1.55.5/models/apis/translate/2017-07-01/api-2.json). handleError in handler.go matches each with errors.Is and emits the exact "__type" wire code; every exception below is smithy.FaultClient (HTTP 400) per the real SDK's ErrorFault() implementations and the AWS API reference's documented "HTTP Status Code: 400" for each -- only InternalServerException and ServiceUnavailableException are FaultServer (500), and neither has a deterministic trigger in this synchronous, single-lock, unbounded in-memory emulator (no internal faults, no real service outages) any more than TooManyRequestsException (no rate limiting) or DetectedLanguageLowConfidenceException (no real Comprehend-backed detection). Generic throttling/5xx injection for any operation is available instead through the chaos fault-injection system (ChaosOperations/ChaosServiceName), matching services/comprehend's documented precedent for the same class of unmodeled-but-real exceptions. ConcurrentModificationException is the one exception in that "no deterministic trigger" family that turned out to have one: this emulator's own CREATING/UPDATING -> ACTIVE async lifecycle (parallel_data.go) is a real, observable non-terminal window, not a genuine goroutine race -- see ErrConcurrentModification below.

View Source
var ErrNilAppContext = errors.New("AppContext is required")

ErrNilAppContext is returned when Provider.Init is called with a nil AppContext.

Functions

This section is empty.

Types

type EncryptionKey

type EncryptionKey struct {
	Type string
	ID   string
}

EncryptionKey holds optional KMS encryption key details.

type Handler

type Handler struct {
	Backend *InMemoryBackend
	// contains filtered or unexported fields
}

Handler serves Amazon Translate JSON operations.

func NewHandler

func NewHandler(backend *InMemoryBackend) *Handler

NewHandler creates a Translate handler backed by in-memory state.

func (*Handler) BackendFor

func (h *Handler) BackendFor(region string) *InMemoryBackend

BackendFor returns the backend serving region: the home backend, or the sibling built on first use.

func (*Handler) ChaosOperations

func (h *Handler) ChaosOperations() []string

ChaosOperations returns fault-injectable operations.

func (*Handler) ChaosRegions

func (h *Handler) ChaosRegions() []string

ChaosRegions returns configured service region.

func (*Handler) ChaosServiceName

func (h *Handler) ChaosServiceName() string

ChaosServiceName returns service key for fault matching.

func (*Handler) EnableRegions

func (h *Handler) EnableRegions()

EnableRegions makes h serve every other region through lazily built per-region siblings.

func (*Handler) ExtractOperation

func (h *Handler) ExtractOperation(c *echo.Context) string

ExtractOperation returns the operation name from the request target.

func (*Handler) ExtractResource

func (h *Handler) ExtractResource(c *echo.Context) string

ExtractResource retrieves the primary resource name.

func (*Handler) GetSupportedOperations

func (h *Handler) GetSupportedOperations() []string

GetSupportedOperations returns all implemented operation names.

func (*Handler) Handler

func (h *Handler) Handler() echo.HandlerFunc

Handler serves each request from the handler of its region.

func (*Handler) MatchPriority

func (h *Handler) MatchPriority() int

MatchPriority returns header matching priority.

func (*Handler) Name

func (h *Handler) Name() string

Name returns service name.

func (*Handler) RegionBackends

func (h *Handler) RegionBackends() []*InMemoryBackend

RegionBackends returns the home backend followed by every sibling built so far.

func (*Handler) RegionHandler

func (h *Handler) RegionHandler(region string) *Handler

RegionHandler returns the handler serving region: h itself for the home region, else its sibling.

func (*Handler) Reset

func (h *Handler) Reset()

Reset clears every region.

func (*Handler) Restore

func (h *Handler) Restore(ctx context.Context, data []byte) error

Restore implements persistence.Persistable.

func (*Handler) RouteMatcher

func (h *Handler) RouteMatcher() service.Matcher

RouteMatcher matches Translate X-Amz-Target headers.

func (*Handler) Snapshot

func (h *Handler) Snapshot(ctx context.Context) []byte

Snapshot implements persistence.Persistable; other regions ride in an additive "regions" key.

type InMemoryBackend

type InMemoryBackend struct {
	// contains filtered or unexported fields
}

InMemoryBackend stores Translate state for concurrent requests.

terminologies, parallelData, and jobs are *store.Table[T]-backed (see store_setup.go and pkgs/store's package doc); tags remains a plain map since its values are map[string]string, not *T, so there is nothing for store.Table to key on.

func NewInMemoryBackend

func NewInMemoryBackend(accountID, region string) *InMemoryBackend

NewInMemoryBackend returns an initialized InMemoryBackend.

func (*InMemoryBackend) AccountID

func (b *InMemoryBackend) AccountID() string

AccountID returns the configured account ID.

func (*InMemoryBackend) CreateParallelData

func (b *InMemoryBackend) CreateParallelData(
	name, description string,
	cfg *ParallelDataConfig,
	encKey *EncryptionKey,
	tags map[string]string,
) (*ParallelData, error)

CreateParallelData creates a new parallel data resource.

func (*InMemoryBackend) DeleteParallelData

func (b *InMemoryBackend) DeleteParallelData(name string) (*ParallelData, error)

DeleteParallelData removes a parallel data resource by name.

func (*InMemoryBackend) DeleteTerminology

func (b *InMemoryBackend) DeleteTerminology(name string) error

DeleteTerminology removes a terminology by name.

func (*InMemoryBackend) DescribeTextTranslationJob

func (b *InMemoryBackend) DescribeTextTranslationJob(jobID string) (*TranslationJob, error)

DescribeTextTranslationJob retrieves a translation job and advances it one step through its lifecycle, matching services/comprehend's DescribeJob pattern: real batch translation jobs move from SUBMITTED to IN_PROGRESS to a terminal state (COMPLETED/FAILED, or STOPPED once stop was requested) asynchronously. Without this, a job started via StartTextTranslationJob would sit at its initial status forever and SDK callers polling DescribeTextTranslationJob (the documented way to track job progress) would never observe completion.

func (*InMemoryBackend) GetParallelData

func (b *InMemoryBackend) GetParallelData(name string) (*ParallelData, error)

GetParallelData retrieves a parallel data resource by name and advances it one step through its async CREATING/UPDATING -> ACTIVE lifecycle. This takes the write lock (not RLock) because advanceParallelData mutates state, matching DescribeTextTranslationJob's documented precedent in text_translation_jobs.go.

func (*InMemoryBackend) GetTerminology

func (b *InMemoryBackend) GetTerminology(name string) (*Terminology, error)

GetTerminology retrieves a terminology by name.

func (*InMemoryBackend) ImportTerminology

func (b *InMemoryBackend) ImportTerminology(
	name, description string,
	data *TerminologyData,
	encKey *EncryptionKey,
	tags map[string]string,
) (*Terminology, error)

ImportTerminology creates or overwrites a custom terminology.

func (*InMemoryBackend) ListParallelData

func (b *InMemoryBackend) ListParallelData(maxResults int, nextToken string) ([]*ParallelData, string)

ListParallelData returns a paginated list of parallel data resources.

func (*InMemoryBackend) ListTagsForResource

func (b *InMemoryBackend) ListTagsForResource(resourceARN string) (map[string]string, error)

ListTagsForResource returns tags for a resource.

func (*InMemoryBackend) ListTerminologies

func (b *InMemoryBackend) ListTerminologies(maxResults int, nextToken string) ([]*Terminology, string)

ListTerminologies returns a paginated list of terminologies.

func (*InMemoryBackend) ListTextTranslationJobs

func (b *InMemoryBackend) ListTextTranslationJobs(
	filter TextTranslationJobFilter,
	maxResults int,
	nextToken string,
) ([]*TranslationJob, string)

ListTextTranslationJobs returns a paginated list of translation jobs.

func (*InMemoryBackend) LookupTerminologies

func (b *InMemoryBackend) LookupTerminologies(names []string) ([]*Terminology, error)

LookupTerminologies returns terminology entries for the given names. A name that does not correspond to any stored terminology is a ResourceNotFoundException (TranslateText/TranslateDocument both model this exception, and TerminologyNames is the only named-resource reference either operation makes -- real AWS's ListTerminologies doc note "Use the ListTerminologies operation to get the available terminology lists" implies the reference is validated, not silently ignored).

func (*InMemoryBackend) Region

func (b *InMemoryBackend) Region() string

Region returns the configured region.

func (*InMemoryBackend) Reset

func (b *InMemoryBackend) Reset()

Reset clears all stored state.

func (*InMemoryBackend) Restore

func (b *InMemoryBackend) Restore(ctx context.Context, data []byte) error

Restore deserializes backend state from a snapshot. It implements persistence.Persistable.

func (*InMemoryBackend) Snapshot

func (b *InMemoryBackend) Snapshot(ctx context.Context) []byte

Snapshot serializes the backend state to JSON. It implements persistence.Persistable.

func (*InMemoryBackend) StartTextTranslationJob

func (b *InMemoryBackend) StartTextTranslationJob(
	jobName, dataAccessRoleARN, sourceLang string,
	targetLangs, terminologyNames, parallelDataNames []string,
	inputCfg, outputCfg, settings map[string]any,
	tags map[string]string,
) (*TranslationJob, error)

StartTextTranslationJob creates a new async translation job.

func (*InMemoryBackend) StopTextTranslationJob

func (b *InMemoryBackend) StopTextTranslationJob(jobID string) (*TranslationJob, error)

StopTextTranslationJob requests stop of a translation job.

func (*InMemoryBackend) TagResource

func (b *InMemoryBackend) TagResource(resourceARN string, newTags map[string]string) error

TagResource adds or replaces tags on a resource.

func (*InMemoryBackend) TaggedResources added in v1.3.1

func (b *InMemoryBackend) TaggedResources() []TaggedEntry

TaggedResources returns every terminology and parallel data ARN that currently has at least one tag applied via TagResource.

func (*InMemoryBackend) UntagResource

func (b *InMemoryBackend) UntagResource(resourceARN string, keys []string) error

UntagResource removes specific tags from a resource.

func (*InMemoryBackend) UpdateParallelData

func (b *InMemoryBackend) UpdateParallelData(
	name, description string,
	cfg *ParallelDataConfig,
) (*ParallelData, error)

UpdateParallelData updates an existing parallel data resource. Real AWS puts the resource into UPDATING (and records a new LatestUpdateAttemptStatus/LatestUpdateAttemptAt attempt) until the update completes asynchronously; GetParallelData's advanceParallelData call carries it to ACTIVE, matching CreateParallelData's CREATING -> ACTIVE lifecycle above.

type ParallelData

type ParallelData struct {
	ParallelDataConfig *ParallelDataConfig
	EncryptionKey      *EncryptionKey
	Tags               map[string]string
	CreatedAt          time.Time
	LastUpdatedAt      time.Time
	// LatestUpdateAttemptAt is the zero time until UpdateParallelData is
	// called at least once.
	LatestUpdateAttemptAt time.Time
	ARN                   string
	Name                  string
	Description           string
	SourceLanguage        string
	Status                string
	// LatestUpdateAttemptStatus tracks the outcome of the most recent
	// UpdateParallelData call (real ParallelDataProperties/
	// UpdateParallelDataOutput field), empty until the first update.
	LatestUpdateAttemptStatus string
	TargetLanguages           []string
}

ParallelData stores a parallel data resource.

type ParallelDataConfig

type ParallelDataConfig struct {
	S3URI  string
	Format string
}

ParallelDataConfig holds S3 data config for parallel data.

type Provider

type Provider struct{}

Provider implements service.Provider for the Translate service.

func (*Provider) Init

Init initializes the Translate backend and handler.

func (*Provider) Name

func (p *Provider) Name() string

Name returns the logical name of the provider.

type TaggedEntry added in v1.3.1

type TaggedEntry struct {
	Tags map[string]string
	ARN  string
}

TaggedEntry pairs a resource ARN with its tags.

type Terminology

type Terminology struct {
	TerminologyData *TerminologyData
	EncryptionKey   *EncryptionKey
	Tags            map[string]string
	CreatedAt       time.Time
	LastUpdatedAt   time.Time
	ARN             string
	Name            string
	Description     string
	SourceLanguage  string
	Directionality  string
	Format          string
	TargetLanguages []string
	SizeBytes       int
	TermCount       int
}

Terminology stores a custom terminology resource.

type TerminologyData

type TerminologyData struct {
	Format         string
	Directionality string
	File           []byte
}

TerminologyData holds imported terminology file bytes.

type TextTranslationJobFilter

type TextTranslationJobFilter struct {
	SubmittedAfterTime  *time.Time
	SubmittedBeforeTime *time.Time
	JobName             string
	JobStatus           string
}

TextTranslationJobFilter mirrors types.TextTranslationJobFilter (api_op_ListTextTranslationJobs.go): JobName/JobStatus/SubmittedAfterTime/ SubmittedBeforeTime, each optional and independently zero-valued when unset.

type TranslationJob

type TranslationJob struct {
	InputDataConfig   map[string]any
	OutputDataConfig  map[string]any
	Settings          map[string]any
	Tags              map[string]string
	SubmittedAt       time.Time
	EndAt             time.Time
	JobID             string
	JobName           string
	JobStatus         string
	DataAccessRoleARN string
	SourceLanguage    string
	Message           string
	TargetLanguages   []string
	TerminologyNames  []string
	ParallelDataNames []string
	// contains filtered or unexported fields
}

TranslationJob stores an async translation job.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL