=encoding utf-8

=head1 NAME

App::Greple::xlate - vertaalondersteuningsmodule voor greple

=head1 SYNOPSIS

    greple -Mxlate --xlate-engine gpt5 --xlate pattern target-file

    greple -Mxlate --xlate-engine deepl --xlate pattern target-file

=head1 VERSION

Version 2.01

=head1 DESCRIPTION

B<Greple> B<xlate>-module zoekt de gewenste tekstblokken en vervangt deze door de vertaalde tekst. De primaire engine is GPT-5.5 (F<llm/gpt5.pm>), die het L<llm|https://llm.datasette.io/>-commando aanroept; DeepL (F<deepl.pm>) en oudere, op B<gpty> gebaseerde engines zijn ook inbegrepen.

Vertalingen worden per bestand in de cache opgeslagen, dus het opnieuw uitvoeren van een commando kost niets voor ongewijzigde tekst. Wanneer een document wordt bewerkt, worden alleen de gewijzigde alinea’s opnieuw naar de API verzonden; een contextbewuste engine ontvangt ook de omringende vertalingen, de onbewerkte brontekst rondom de wijziging en de vorige versie van de bewerkte alinea, zodat de nieuwe vertaling de gevestigde bewoording behoudt (zie B<--xlate-context-window>). Gevoelige tekenreeksen kunnen vóór verzending worden verborgen (zie L</ANONYMIZATION AND TEMPLATES>).

Als u normale tekstblokken wilt vertalen in een document dat is geschreven in de pod-stijl van Perl, gebruikt u het B<greple>-commando met de C<--xlate-engine gpt5>- en C<perl>-module als volgt:

    greple -Mxlate --xlate-engine gpt5 -Mperl --pod --re '^([\w\pP].*\n)+' --all foo.pm

In deze opdracht betekent patroontekenreeks C<^([\w\pP].*\n)+> opeenvolgende regels die beginnen met alfanumerieke letters en leestekens. Deze opdracht laat het te vertalen gebied gemarkeerd zien. Optie B<--all> wordt gebruikt om de volledige tekst te produceren.

=for html <p>
<img width="750" src="https://raw.githubusercontent.com/kaz-utashiro/App-Greple-xlate/main/images/select-area.png">
</p>

Voeg vervolgens de optie C<--xlate> toe om het geselecteerde gebied te vertalen. Vervolgens worden de gewenste secties gevonden en vervangen door de uitvoer van de vertaalengine.

Standaard wordt originele en vertaalde tekst afgedrukt in het "conflict marker" formaat dat compatibel is met L<git(1)>. Door C<ifdef> formaat te gebruiken, kun je gemakkelijk het gewenste deel krijgen met L<unifdef(1)> commando. Uitvoerformaat kan gespecificeerd worden met B<--xlate-format> optie.

=for html <p>
<img width="750" src="https://raw.githubusercontent.com/kaz-utashiro/App-Greple-xlate/main/images/format-conflict.png">
</p>

Als je de hele tekst wilt vertalen, gebruik dan de optie B<--match-all>. Dit is een snelkoppeling om het patroon C<(?s).+> op te geven dat overeenkomt met de hele tekst.

Gegevens in conflictmarkerformaat kunnen naast elkaar worden bekeken met het L<sdif|App::sdif> commando met de C<-V> optie. Omdat het geen zin heeft om per string te vergelijken, wordt de optie C<--no-cdif> aanbevolen. Als je de tekst niet hoeft te kleuren, geef dan C<--no-textcolor> op (of C<--no-tc>).

    sdif -V --no-filename --no-tc --no-cdif data_shishin.deepl-EN-US.cm

=for html <p>
<img width="750" src="https://raw.githubusercontent.com/kaz-utashiro/App-Greple-xlate/main/images/sdif-cm-view.png">
</p>

=head1 NORMALIZATION

De verwerking wordt gedaan in gespecificeerde eenheden, maar in het geval van een opeenvolging van meerdere regels niet-lege tekst, worden ze samen omgezet in een enkele regel. Deze bewerking wordt als volgt uitgevoerd:

=over 2

=item *

Verwijder witruimte aan het begin en einde van elke regel.

=item *

Als een regel eindigt met een leesteken over de hele breedte, aaneenschakelen met de volgende regel.

=item *

Als een regel eindigt met een teken van volledige breedte en de volgende regel begint met een teken van volledige breedte, worden de regels aan elkaar gekoppeld.

=item *

Als het einde of het begin van een regel geen teken voor de volledige breedte is, voeg ze dan samen door een spatieteken in te voegen.

=back

Cachegegevens worden beheerd op basis van de genormaliseerde tekst, dus zelfs als er wijzigingen worden aangebracht die geen invloed hebben op de normalisatieresultaten, zullen de vertaalgegevens in de cache nog steeds effectief zijn.

Dit normalisatieproces wordt alleen uitgevoerd voor het eerste (0e) en even genummerde patroon. Dus als twee patronen als volgt worden gespecificeerd, wordt de tekst die overeenkomt met het eerste patroon verwerkt na normalisatie en wordt er geen normalisatieproces uitgevoerd op de tekst die overeenkomt met het tweede patroon.

    greple -Mxlate -E normalized -E not-normalized

Gebruik daarom het eerste patroon voor tekst die verwerkt moet worden door meerdere regels samen te voegen tot een enkele regel, en gebruik het tweede patroon voor voorgeformatteerde tekst. Als er geen tekst is om mee te matchen in het eerste patroon, gebruik dan een patroon dat nergens mee overeenkomt, zoals C<(?!)>.

=head1 MASKING

Soms zijn er delen van tekst die je niet vertaald wilt hebben. Bijvoorbeeld tags in markdown-bestanden. DeepL stelt voor dat in dergelijke gevallen het deel van de tekst dat moet worden uitgesloten, wordt geconverteerd naar XML-tags, wordt vertaald en vervolgens wordt hersteld nadat de vertaling is voltooid. Om dit te ondersteunen, is het mogelijk om de delen te specificeren die moeten worden gemaskeerd van vertaling.

    --xlate-setopt maskfile=MASKPATTERN

Hierdoor wordt elke regel van het bestand C<MASKPATTERN> geïnterpreteerd als een reguliere expressie, worden strings die hiermee overeenkomen vertaald en wordt na verwerking de oorspronkelijke tekst hersteld. Regels die beginnen met C<#> worden genegeerd.

Complexe patronen kunnen over meerdere regels worden geschreven met een door een backslash geëscapeerde regeleinde.

Hoe de tekst door het maskeren wordt omgezet, kun je zien met de optie B<--xlate-mask>.

Door maskering wordt markup beschermd tegen vertaling. Om gevoelige tekenreeksen te verbergen voor de vertaaldienst zelf, zie L</ANONYMIZATION AND TEMPLATES>; beide kunnen samen worden gebruikt.

Deze interface is experimenteel en kan in de toekomst veranderen.

=head1 ANONYMIZATION AND TEMPLATES

Gevoelige tekenreeksen kunnen worden verborgen voordat ze naar de vertaal-API worden verzonden en in de uitvoer weer worden weergegeven. Er zijn drie bronnen voor anonimiseringsregels beschikbaar: een woordenboekbestand (B<--xlate-anonymize>), inline-markeringen in het document zelf (B<--xlate-anonymize-mark>) en YAML-frontmatter-waarden (B<--xlate-frontmatter>). Elke tekenreeks wordt tijdens de overdracht vervangen door een categorietag, zoals C<< <person id=1 /> >>. Het verbergen geldt alleen voor de API-overdracht: lokale cachebestanden slaan de herstelde platte tekst op. Gebruik B<--xlate-dryrun> om precies te controleren wat er zou worden verzonden.

Voor formulierdocumenten (kwartaalrapporten en dergelijke) definieer je de actoren vooraf en verwijs je ernaar in de hoofdtekst:

    ---
    報告者: 山田太郎
    発注会社: アクメ株式会社
    ---
    本件について {{ 報告者 }} が調査を行った。

Vertaal het sjabloon één keer per taal met C<--xlate-template> (en C<--xlate-frontmatter> wanneer de waarden in het bestand worden bewaard), en geef vervolgens elk geval weer met B<pandoc-embedz> in de standalone-modus — waarden onder C<global:> in een externe configuratie bereiken de vertaal-API helemaal niet:

    greple -Mxlate --xlate --xlate-engine=gpt5 --xlate-to=EN-US \
           --xlate-template= --xlate-format=xtxt \
           --match-paragraph --all --need=0 \
           report-template.md > report-template.EN.md
    pandoc-embedz --standalone report-template.EN.md \
                  -c case-123.yaml -o report-123.EN.md < /dev/null

Voor inline-markeringen zorgt het opgeven van een macrodefinitieconfiguratie ervoor dat dezelfde vertaalde sjabloon ofwel de echte namen ofwel een geredigeerde versie weergeeft:

    # macros.yaml           # macros-redacted.yaml
    preamble: |             preamble: |
      {% macro person(name) %}{{ name }}{% endmacro %}
                              {% macro person(name) %}(関係者){% endmacro %}

Sluit embedz-blokken uit van vertaling wanneer een document deze bevat:

    --exclude '^```embedz\n(?s:.*?)^```\n'

=head1 OPTIONS

=over 7

=item B<--xlate>

=item B<--xlate-color>

=item B<--xlate-fold>

=item B<--xlate-fold-width>=I<n> (Default: 70)

Roep het vertaalproces op voor elk gematcht gebied.

Zonder deze optie gedraagt B<greple> zich als een normaal zoekcommando. U kunt dus controleren welk deel van het bestand zal worden vertaald voordat u het eigenlijke werk uitvoert.

Commandoresultaat gaat naar standaard out, dus redirect naar bestand indien nodig, of overweeg L<App::Greple::update> module te gebruiken.

Optie B<--xlate> roept B<--xlate-kleur> aan met B<--color=never> optie.

Met de optie B<--xlate-fold> wordt geconverteerde tekst gevouwen met de opgegeven breedte. De standaardbreedte is 70 en kan worden ingesteld met de optie B<--xlate-fold-width>. Vier kolommen zijn gereserveerd voor inloopoperaties, zodat elke regel maximaal 74 tekens kan bevatten.

=item B<--xlate-engine>=I<engine>

Hiermee wordt de te gebruiken vertaalengine gespecificeerd.

Op dit moment zijn de volgende engines beschikbaar

=over 2

=item * B<gpt5>: gpt-5.5 (via the C<llm> command)

=item * B<deepl>: DeepL API (via the C<deepl> command)

=item * B<gpt3>: gpt-3.5-turbo (legacy, via the C<gpty> command)

=item * B<gpt4o>: gpt-4o-mini (legacy, via the C<gpty> command)

=back

Engine-modules worden eerst doorzocht in backend-naamruimten (C<llm>, daarna C<gpty>), vervolgens direct onder C<App::Greple::xlate>. Dus C<gpt5> laadt C<App::Greple::xlate::llm::gpt5>, dat het C<llm>-commando aanroept, terwijl C<gpt4o> terugvalt op C<App::Greple::xlate::gpty::gpt4o>. Gebruik C<--xlate-setopt backend=gpty> om een specifieke backend te forceren.

=item B<--xlate-labor>

=item B<--xlabor>

In plaats van de vertaalmachine op te roepen, wordt er van je verwacht dat je zelf aan de slag gaat. Na het voorbereiden van tekst die vertaald moet worden, worden ze gekopieerd naar het klembord. Er wordt van je verwacht dat je ze op het formulier plakt, het resultaat naar het klembord kopieert en op return drukt.

=item B<--xlate-to> (Default: C<EN-US>)

Geef de doeltaal op. LLM-engines accepteren elke taalnaam of -code die het model begrijpt; deze wordt in de vertaalprompt geïnterpoleerd. Je kunt de beschikbare talen opvragen met het C<deepl languages>-commando wanneer je de B<DeepL>-engine gebruikt.

=item B<--xlate-from> (Default: C<ORIGINAL>)

Label dat wordt gebruikt voor de oorspronkelijke tekst in de uitvoerformaten C<conflict>, C<colon> en C<ifdef>. Bij de B<DeepL>-engine wordt ook een niet-standaardwaarde doorgegeven als brontaal.

=item B<--xlate-format>=I<format> (Default: C<conflict>)

Specificeer het uitvoerformaat voor originele en vertaalde tekst.

De volgende indelingen anders dan C<xtxt> gaan ervan uit dat het te vertalen deel een verzameling regels is. In feite is het mogelijk om slechts een deel van een regel te vertalen, maar het specificeren van een andere opmaak dan C<xtxt> zal geen zinvolle resultaten opleveren.

=over 4

=item B<conflict>, B<cm>

Originele en geconverteerde tekst worden afgedrukt in L<git(1)> conflictmarkeerder formaat.

    <<<<<<< ORIGINAL
    original text
    =======
    translated Japanese text
    >>>>>>> JA

U kunt het originele bestand herstellen met de volgende L<sed(1)> opdracht.

    sed -e '/^<<<<<<< /d' -e '/^=======$/,/^>>>>>>> /d'

=item B<colon>, I<:::::::>

De originele en vertaalde tekst worden uitgevoerd in de aangepaste containerstijl van markdown.

    ::::::: ORIGINAL
    original text
    :::::::
    ::::::: JA
    translated Japanese text
    :::::::

Bovenstaande tekst wordt vertaald naar het volgende in HTML.

    <div class="ORIGINAL">
    original text
    </div>
    <div class="JA">
    translated Japanese text
    </div>

Het aantal dubbele punten is standaard 7. Als je een dubbele punt reeks specificeert zoals C<:::::>, wordt deze gebruikt in plaats van 7 dubbele punten.

=item B<ifdef>

Originele en geconverteerde tekst worden afgedrukt in L<cpp(1)> C<#ifdef> formaat.

    #ifdef ORIGINAL
    original text
    #endif
    #ifdef JA
    translated Japanese text
    #endif

U kunt alleen Japanse tekst terughalen met het commando B<unifdef>:

    unifdef -UORIGINAL -DJA foo.ja.pm

=item B<space>

=item B<space+>

Originele en geconverteerde tekst worden gescheiden afgedrukt door een enkele lege regel. Voor C<space+> wordt ook een nieuwe regel na de geconverteerde tekst afgedrukt.

=item B<xtxt>

Als het formaat C<xtxt> (vertaalde tekst) of onbekend is, wordt alleen vertaalde tekst afgedrukt.

=back

=item B<--xlate-maxlen>=I<chars> (Default: 0)

Geef de maximale lengte op van de tekst die in één keer naar de API mag worden verzonden. De standaardwaarde 0 betekent de eigen limiet van de engine: voor de gratis DeepL-accountservice is dat 128K voor de API (B<--xlate>) en 5000 voor de klembordinterface (B<--xlate-labor>). U kunt deze waarden mogelijk wijzigen als u de Pro-service gebruikt.

=item B<--xlate-maxline>=I<n> (Default: 0)

Geef het maximum aantal regels tekst op dat in één keer naar de API moet worden gestuurd.

Stel deze waarde in op 1 als je één regel per keer wilt vertalen. Deze optie heeft voorrang op de C<--xlate-maxlen> optie.

=item B<--xlate-prompt>=I<text>

Geef een aangepaste prompt op die naar de vertaalengine moet worden verzonden. Deze optie is beschikbaar voor de LLM-engines (C<gpt3>, C<gpt4o>, C<gpt5>), maar niet voor DeepL. U kunt het vertaalgedrag aanpassen door specifieke instructies aan het AI-model te geven. Als de prompt C<%s> bevat, wordt dit vervangen door de naam van de doeltaal.

=item B<--xlate-context>=I<text>

Geef aanvullende contextinformatie op die naar de vertaalmachine moet worden gestuurd. Deze optie kan meerdere keren worden gebruikt om meerdere contextstrings op te geven. De contextinformatie helpt de vertaalmachine om de achtergrond te begrijpen en nauwkeurigere vertalingen te produceren.

=item B<--xlate-context-window>=I<n>

(Context-aware engines only, e.g. C<gpt5> on the llm backend)
Aantal omliggende vertaalde blokken die als referentiecontext worden doorgegeven bij het opnieuw vertalen van gewijzigde blokken (standaard 2). De context omvat ook de onbewerkte brontekst rondom het gewijzigde gebied (koppen, lijststructuur, bijschriften) en, indien beschikbaar, de vorige versie van de gewijzigde tekst die uit de cache is opgehaald, zodat ongewijzigde bewoordingen behouden blijven. Stel deze waarde in op 0 om contextbewuste vertaling volledig uit te schakelen. Houd er rekening mee dat elk gewijzigd gebied in een eigen API-aanroep wordt vertaald en dat de context tot ongeveer 8000 tekens aan de systeemprompt kan toevoegen; contextbewuste vertaling brengt dus enige extra kosten met zich mee in ruil voor consistentie.

=item B<--xlate-cache-seed>=I<file>

Initialiseer de cache van een nieuw document vanuit het cachebestand van een ander document. Handig voor periodieke rapporten: vul de cache van de nieuwe uitgave aan met die van de vorige uitgave, zodat ongewijzigde alinea’s niet opnieuw worden vertaald en bewerkte alinea’s de formulering van de vorige uitgave behouden. De seed wordt alleen gebruikt als de doelcache leeg is; anders wordt deze genegeerd en wordt er een waarschuwing gegeven. Met de standaardinstelling C<--xlate-cache=auto> houdt het opgeven van een seed ook in dat het cachebestand van het nieuwe document wordt aangemaakt.

=item B<--xlate-anonymize>=I<file>

Anonimiseer gevoelige tekenreeksen voordat ze naar de vertaal-API worden verzonden, en herstel ze in de uitvoer. Het woordenboekbestand bevat één vermelding per item: in JSON (canonisch, machinaal genereerbaar)

    [ { "category": "person",  "text": "山田太郎" },
      { "category": "company", "regex": "アクメ(株式会社)?" } ]

of in een eenvoudig regelformaat (C<category pattern>, C</.../> voor regex). Elk item wordt vervangen door een categorietag zoals C<< <person id=1 /> >>; dezelfde tekenreeks krijgt altijd dezelfde tag, zodat het model kan bijhouden wie wie is. Onbekende JSON-velden worden genegeerd, zodat generatoren (bijv. een lokale LLM die entiteiten extraheert) hun eigen annotaties kunnen toevoegen. Categorie C<lit> is gereserveerd. Lokale cachebestanden slaan nog steeds de herstelde platte tekst op: het verbergen is uitsluitend bedoeld voor API-overdracht.

Een woordenboek kan worden gegenereerd door een externe tool – bijvoorbeeld een lokaal model dat gevoelige entiteiten extraheert:

    llm -m <local-model> \
        -s 'Extract sensitive entities as a JSON array of objects
            with "category" and "text" fields.' \
        < report.md > report.anon.json
    greple -Mxlate --xlate-anonymize=report.anon.json ...

Een UTF-8 BOM in het bestand wordt getolereerd. Waarden in het ‘front matter’-regelformaat mogen alleen een afsluitende opmerking op hun eigen regel bevatten, niet na de waarde.

=item B<--xlate-anonymize-mark>[=I<regex>]

Verzamel anonimiseringsvermeldingen uit inline-markeringen in het document zelf. Markeer de eerste keer dat de tekenreeks voorkomt als C<{{ person("山田太郎") }}> en elke keer dat de tekenreeks in het hele document voorkomt, wordt deze geanonimiseerd. De markering zelf blijft in de bron en in de vertaling staan, zodat een document ook kan worden verwerkt door een Jinja2-achtige macroprocessor (definieer de C<person>-macro om de naam af te drukken of te redigeren). Een aangepaste I<regex> moet de benoemde captures C<< (?<category>...) >> en C<< (?<text>...) >> bevatten.

Merk op dat bij een optie met een optionele waarde zoals deze, een volgend bestandsargument als waarde wordt beschouwd: schrijf C<--xlate-anonymize-mark=> (met een afsluitende C<=>) bij gebruik van de standaardnotatie.

Alternatieve notaties kunnen worden geconfigureerd, bijvoorbeeld C<< --xlate-anonymize-mark='@@(?<category>[a-z][a-z0-9_]*):(?<text>[^\n]+?)@@' >> voor markeringen in de stijl van C<@@person:NAME@@>, of een HTML-commentaarvorm die onzichtbaar blijft in weergegeven Markdown. Markeringsregels worden per document verzameld: een tekenreeks die in één invoerbestand is gemarkeerd, wordt niet verborgen in een ander bestand van dezelfde run (in tegenstelling tot front-matter-waarden, die over bestanden heen worden opgeteld).

=item B<--xlate-template>[=I<regex>]

Behandel sjabloonuitdrukkingen (standaard: Jinja2 C<{{ ... }}>, C<{% ... %}>, C<{# ... #}>) als ondoorzichtige plaatshouders: geef het model de opdracht om ze ongewijzigd te kopiëren en controleer per blok of het antwoord precies dezelfde uitdrukkingen bevat, elk even vaak. Hun volgorde kan veranderen, aangezien de vertaling ze terecht herschikt om de woordvolgorde van de doeltaal te volgen. Een ongeldige uitdrukking breekt de run af; de cache wordt vastgelegd en bevroren, zodat niets waarvoor betaald is, verloren gaat.

Merk op dat bij een optie met een optionele waarde zoals deze, een volgend bestandsargument als de waarde zou worden beschouwd: schrijf C<--xlate-template=> (met een afsluitend C<=>) bij gebruik van de standaardnotatie.

=item B<--xlate-frontmatter>

Behandel een inleidend C<---> ... C<--->-blok als YAML-frontmatter: sluit het uit van de vertaling en van de fase-2-contextfragmenten, en voeg de platte C<key: value>-waarden ervan toe aan de anonimiseringsregels (categorie C<var>) als vangnet. Bij meerdere invoerbestanden worden de verzamelde waarden opgeteld (waarbij het zekere voor het onzekere wordt genomen).

Laat altijd een lege regel achter na de afsluitende C<--->. Bij een overeenkomend patroon in paragraafstijl vormt front matter dat direct overgaat in de hoofdtekst één blok dat de uitsluiting niet kan onderdrukken (in dat geval wordt een waarschuwing weergegeven); de waarden worden nog steeds geanonimiseerd, maar de voorpagina zelf zou voor vertaling worden verzonden.

=item B<--xlate-glossary>=I<glossary>

Geef een woordenlijst-ID op die moet worden gebruikt voor vertaling. Deze optie is alleen beschikbaar wanneer je de DeepL engine gebruikt. De woordenlijst-ID moet verkregen worden via je DeepL account en zorgt voor een consistente vertaling van specifieke termen.

=item B<--xlate-dryrun>

Roep de vertaal-API niet aan; toon in plaats daarvan via de voortgangsbalk elke payload precies zoals deze zou worden verzonden (na anonimisering en maskering). Handig om te controleren wat de machine verlaat en om de kosten van een vertaalrun in te schatten.

=item B<-->[B<no->]B<xlate-progress> (Default: True)

Bekijk het vertaalresultaat in realtime in de STDERR-uitvoer. De C<From>-payload wordt weergegeven zoals deze wordt verzonden, na anonimisering en maskering.

=item B<--xlate-stripe>

Gebruik de module L<App::Greple::stripe> om het gematchte deel weer te geven met zebrastrepen. Dit is nuttig wanneer de gematchte delen rug-aan-rug verbonden zijn.

Het kleurenpalet wordt omgeschakeld volgens de achtergrondkleur van de terminal. Als je dit expliciet wilt specificeren, kun je B<--xlate-stripe-light> of B<--xlate-stripe-dark> gebruiken.

=item B<--xlate-mask>

Voer de maskeerfunctie uit en geef de geconverteerde tekst weer zoals hij is, zonder restauratie.

=item B<--match-all>

Stel de hele tekst van het bestand in als doelgebied.

=item B<--lineify-cm>

=item B<--lineify-colon>

In het geval van de C<cm> en C<colon> opmaak wordt de uitvoer regel voor regel opgesplitst en opgemaakt. Daarom kan het verwachte resultaat niet worden verkregen als slechts een deel van een regel moet worden vertaald. Deze filters herstellen uitvoer die beschadigd is door het vertalen van een deel van een regel naar normale regel-voor-regel uitvoer.

In de huidige implementatie, als meerdere delen van een regel worden vertaald, worden ze uitgevoerd als onafhankelijke regels.

=back

=head1 CACHE OPTIONS

De module B<xlate> kan de tekst van de vertaling voor elk bestand in de cache opslaan en lezen vóór de uitvoering om de overhead van het vragen aan de server te elimineren. Met de standaard cache strategie C<auto>, onderhoudt het alleen cache gegevens wanneer het cache bestand bestaat voor het doelbestand.

Gebruik B<--xlate-cache=clear> om cachebeheer te starten of om alle bestaande cachegegevens op te ruimen. Eenmaal uitgevoerd met deze optie, zal een nieuw cachebestand worden aangemaakt als er geen bestaat en daarna automatisch worden onderhouden.

=over 7

=item --xlate-cache=I<strategy>

=over 4

=item C<auto> (Default)

Onderhoud het cachebestand als het bestaat.

=item C<create>

Maak een leeg cache bestand en sluit af.

=item C<always>, C<yes>, C<1>

Cache-bestand toch behouden voor zover het doelbestand een normaal bestand is.

=item C<clear>

Wis eerst de cachegegevens.

=item C<never>, C<no>, C<0>

Cache-bestand nooit gebruiken, zelfs niet als het bestaat.

=item C<accumulate>

Standaard worden ongebruikte gegevens uit het cachebestand verwijderd. Als u ze niet wilt verwijderen en in het bestand wilt houden, gebruik dan C<accumuleren>.

=back

=item B<--xlate-update>

Deze optie dwingt om het cachebestand bij te werken, zelfs als dat niet nodig is.

=back

=head1 COMMAND LINE INTERFACE

Je kunt deze module eenvoudig vanaf de commandoregel gebruiken met het C<xlate> commando dat bij de distributie zit. Zie de C<xlate> man pagina voor het gebruik.

Het C<xlate> commando ondersteunt GNU-stijl lange opties zoals C<--to-lang>, C<--from-lang>, C<--engine>, en C<--file>. Gebruik C<xlate -h> om alle beschikbare opties te zien.

Het C<xlate> commando werkt samen met de Docker omgeving, dus zelfs als je niets geïnstalleerd hebt, kun je het gebruiken zolang Docker beschikbaar is. Gebruik de optie C<-D> of C<-C>.

Docker-operaties worden afgehandeld door L<App::dozo>, dat ook als zelfstandig commando kan worden gebruikt. Het C<dozo> commando ondersteunt het C<.dozorc> configuratiebestand voor persistente containerinstellingen.

Omdat er makefiles voor verschillende documentstijlen worden meegeleverd, is vertaling naar andere talen mogelijk zonder speciale specificaties. Gebruik de optie C<-M>.

Je kunt ook de Docker en C<make> opties combineren, zodat je C<make> in een Docker omgeving kunt draaien.

Uitvoeren als C<xlate -C> zal een shell starten met de huidige werkende git repository aangekoppeld.

Lees het Japanse artikel in de L</SEE ALSO> sectie voor meer informatie.

=head1 EMACS

Laad het F<xlate.el> bestand in het archief om het C<xlate> commando te gebruiken vanuit de Emacs editor. C<xlate-region> functie vertaalt de gegeven regio. De standaardtaal is C<EN-US> en u kunt de taal specificeren met het prefix argument.

=for html <p>
<img width="750" src="https://raw.githubusercontent.com/kaz-utashiro/App-Greple-xlate/main/images/emacs.png">
</p>

=head1 ENVIRONMENT

=over 7

=item DEEPL_AUTH_KEY

Stel uw authenticatiesleutel in voor DeepL service.

=item OPENAI_API_KEY

OpenAI-authenticatiesleutel, gebruikt door de oudere B<gpty>-engines. De op C<llm> gebaseerde B<gpt5>-engine leest deze variabele ook, maar sleutels die met C<llm keys set openai> zijn opgeslagen, werken eveneens.

=item GREPLE_XLATE_CACHE

Stel de standaardcachestrategie in (zie L</CACHE OPTIONS>).

=back

=head1 INSTALL

=head2 CPANMINUS

    $ cpanm App::Greple::xlate

=head2 TOOLS

Installeer het opdrachtregelprogramma voor de engine die je gebruikt: C<llm> voor de B<gpt5>-engine, C<deepl> voor DeepL, C<gpty> voor de verouderde GPT-engines.

L<https://llm.datasette.io/>

L<https://github.com/DeepLcom/deepl-python>

L<https://github.com/tecolicom/App-gpty>

=head1 SEE ALSO

=head2 MODULES

L<App::Greple::xlate::llm>, L<App::Greple::xlate::deepl>

L<App::dozo> - Generieke Docker runner gebruikt door xlate voor containeroperaties

=head2 RELATED MODULES

=over 2

=item * L<App::Greple>

Zie de B<greple> handleiding voor de details over het doeltekstpatroon. Gebruik B<--inside>, B<--outside>, B<--include>, B<--exclude> opties om het overeenkomende gebied te beperken.

=item * L<App::Greple::update>

U kunt de module C<-Mupdate> gebruiken om bestanden te wijzigen door het resultaat van het commando B<greple>.

=item * L<App::sdif>

Gebruik B<sdif> om het formaat van de conflictmarkering naast de optie B<-V> te tonen.

=item * L<App::Greple::stripe>

Greple B<stripe> module gebruik door B<--xlate-stripe> optie.

=back

=head2 RESOURCES

=over 2

=item * L<https://hub.docker.com/r/tecolicom/xlate>

Docker containerafbeelding.

=item * L<https://github.com/tecolicom/getoptlong>

De C<getoptlong.sh> bibliotheek gebruikt voor optie parsing in het C<xlate> script en L<App::dozo>.

=item * L<https://llm.datasette.io/>

Het C<llm>-commando dat door de B<gpt5>-engine wordt gebruikt om toegang te krijgen tot LLM-modellen.

=item * L<https://github.com/DeepLcom/deepl-python>

DeepL Python bibliotheek en CLI commando.

=item * L<https://github.com/openai/openai-python>

OpenAI Python Bibliotheek

=item * L<https://github.com/tecolicom/App-gpty>

OpenAI opdrachtregelinterface

=back

=head2 ARTICLES

=over 2

=item * L<https://qiita.com/kaz-utashiro/items/1c1a51a4591922e18250>

Greple module om alleen de benodigde onderdelen te vertalen en te vervangen met DeepL API (in het Japans)

=item * L<https://qiita.com/kaz-utashiro/items/a5e19736416ca183ecf6>

Documenten genereren in 15 talen met DeepL API-module (in het Japans)

=item * L<https://qiita.com/kaz-utashiro/items/1b9e155d6ae0620ab4dd>

Automatisch vertaalde Docker-omgeving met DeepL API (in het Japans)

=back

=head1 AUTHOR

Kazumasa Utashiro

=head1 LICENSE

Copyright © 2023-2026 Kazumasa Utashiro.

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.

=cut
