=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 vindt 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 legacy B<gpty>-gebaseerde engines zijn ook inbegrepen.

Vertalingen worden per bestand gecachet, 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 gestuurd; een contextbewuste engine ontvangt ook de omringende vertalingen, de ruwe brontekst rond de wijziging en de vorige versie van de bewerkte alinea, zodat de nieuwe vertaling de gevestigde formulering behoudt (zie B<--xlate-context-window>). Gevoelige strings 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, gebruik dan de opdracht B<greple> met C<--xlate-engine gpt5> en de module C<perl> zoals dit:

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

In dit commando betekent de patroonstring C<^([\w\pP].*\n)+> opeenvolgende regels die beginnen met alfanumerieke en leestekens. Dit commando toont het te vertalen gebied gemarkeerd. 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. Dan worden de gewenste secties gevonden en vervangen door de uitvoer van de vertaalengine.

Standaard worden originele en vertaalde tekst afgedrukt in het "conflict marker"-formaat dat compatibel is met L<git(1)>. Met C<ifdef>-formaat kun je het gewenste deel gemakkelijk verkrijgen met het L<unifdef(1)>-commando. Het uitvoerformaat kan worden gespecificeerd met de optie B<--xlate-format>.

=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 volledige 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 volledige tekst.

Gegevens in conflict marker-formaat kunnen in zij-aan-zij-stijl worden bekeken met het L<sdif|App::sdif>-commando met optie C<-V>. Aangezien het geen zin heeft om per string te vergelijken, wordt de optie C<--no-cdif> aanbevolen. Als je de tekst niet hoeft te kleuren, specificeer C<--no-textcolor> (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 gebeurt in gespecificeerde eenheden, maar in het geval van een reeks van meerdere regels niet-lege tekst worden ze samen omgezet in één 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 full-width leesteken, concateneer met de volgende regel.

=item *

Als een regel eindigt met een full-width teken en de volgende regel begint met een full-width teken, concateneer de regels.

=item *

Als het einde of het begin van een regel geen full-width teken is, concateneer ze door een spatie in te voegen.

=back

Cachegegevens worden beheerd op basis van de genormaliseerde tekst, dus zelfs als wijzigingen worden aangebracht die de normalisatieresultaten niet beïnvloeden, blijft de vertaalde cachedata effectief.

Dit normalisatieproces wordt alleen uitgevoerd voor het eerste (0e) en even genummerde patroon. Dus als twee patronen als volgt worden opgegeven, 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 moet worden verwerkt door meerdere regels te combineren tot één regel, en gebruik het tweede patroon voor vooraf opgemaakte tekst. Als er geen tekst is die overeenkomt met het eerste patroon, gebruik dan een patroon dat nergens mee overeenkomt, zoals C<(?!)>.

=head1 MASKING

Soms zijn er delen van de tekst die je niet wilt vertalen. Bijvoorbeeld tags in markdown-bestanden. DeepL stelt voor om in dergelijke gevallen het te uitsluiten deel van de tekst om te zetten naar XML-tags, te vertalen en daarna na voltooiing van de vertaling te herstellen. Ter ondersteuning hiervan is het mogelijk om de delen die van vertaling moeten worden gemaskeerd op te geven.

    --xlate-setopt maskfile=MASKPATTERN

Dit zal elke regel van het bestand C<MASKPATTERN> interpreteren als een reguliere expressie, strings die ermee overeenkomen vertalen en terugdraaien na verwerking. Regels die beginnen met C<#> worden genegeerd.

Een complex patroon kan over meerdere regels worden geschreven met een backslash-geëscapete regeleinde.

Hoe de tekst door maskering wordt getransformeerd, is te zien met de optie B<--xlate-mask>.

Maskering beschermt markup tegen vertaling. Om gevoelige strings voor de vertaaldienst zelf te verbergen, 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 worden hersteld. Er zijn drie bronnen voor anonimiseringsregels beschikbaar: een woordenboekbestand (B<--xlate-anonymize>), inline-markeringen in het document zelf (B<--xlate-anonymize-mark>) en YAML-frontmatterwaarden (B<--xlate-frontmatter>). Elke tekenreeks wordt tijdens de transmissie vervangen door een categorietag zoals C<< <person id=1 /> >>. Het doel van de verhulling is alleen API-transmissie: lokale cachebestanden slaan herstelde platte tekst op. Gebruik B<--xlate-dryrun> om precies te inspecteren wat er zou worden verzonden.

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

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

Vertaal de sjabloon één keer per taal met C<--xlate-template> (en C<--xlate-frontmatter> wanneer de waarden in het bestand worden bewaard), en render vervolgens elk geval met de standalone-modus B<pandoc-embedz> -- 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 configuratie voor macrodefinities ervoor dat dezelfde vertaalde sjabloon ofwel de echte namen ofwel een geredigeerde versie rendert:

    # 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 ze 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)

Start het vertaalproces voor elk overeenkomend gebied.

Zonder deze optie gedraagt B<greple> zich als een normale zoekopdracht. Zo kun je controleren welk deel van het bestand onderwerp van de vertaling zal zijn voordat je het echte werk start.

Het commandoresultaat gaat naar standaarduitvoer, dus leid indien nodig om naar een bestand, of overweeg het gebruik van de module L<App::Greple::update>.

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

Met optie B<--xlate-fold> wordt geconverteerde tekst opgevouwen tot de opgegeven breedte. De standaardbreedte is 70 en kan worden ingesteld met optie B<--xlate-fold-width>. Er zijn vier kolommen gereserveerd voor run-in-bewerking, dus elke regel kan maximaal 74 tekens bevatten.

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

Specificeert de te gebruiken vertaalengine.

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 gezocht 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 commando C<llm> aanroept, terwijl C<gpt4o> terugvalt op C<App::Greple::xlate::gpty::gpt4o>. Gebruik C<--xlate-setopt backend=gpty> om een specifieke backend af te dwingen.

=item B<--xlate-labor>

=item B<--xlabor>

In plaats van de vertaalengine aan te roepen, wordt verwacht dat jij het werk doet. Na het voorbereiden van de te vertalen tekst worden deze naar het klembord gekopieerd. Je wordt verondersteld ze in het formulier te plakken, het resultaat naar het klembord te kopiëren en op return te drukken.

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

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

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

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

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

Specificeer de uitvoerindeling 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 slechts een gedeelte van een regel te vertalen, maar het specificeren van een andere indeling dan C<xtxt> levert geen zinvol resultaat op.

=over 4

=item B<conflict>, B<cm>

Originele en geconverteerde tekst worden afgedrukt in L<git(1)>-conflictmarkeringsformaat.

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

Je kunt het originele bestand herstellen met het volgende commando L<sed(1)>.

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

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

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

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

Bovenstaande tekst wordt in HTML als volgt vertaald.

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

Het aantal dubbele punten is standaard 7. Als je een reeks dubbele punten opgeeft zoals C<:::::>, wordt die 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

Je kunt alleen Japanse tekst ophalen met het commando B<unifdef>:

    unifdef -UORIGINAL -DJA foo.ja.pm

=item B<space>

=item B<space+>

Originele en geconverteerde tekst worden afgedrukt, gescheiden door één lege regel. Voor C<space+> wordt ook een regeleinde na de geconverteerde tekst uitgegeven.

=item B<xtxt>

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

=back

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

Geef de maximale lengte op van tekst die in één keer naar de API wordt 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>). Mogelijk kunt u deze waarden wijzigen als u de Pro-service gebruikt.

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

Geef het maximale aantal regels tekst op dat in één keer naar de API wordt verzonden.

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

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

Geef een aangepaste prompt op die naar de vertaalengine wordt gestuurd. 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 extra contextinformatie op die naar de vertaalmachine wordt gestuurd. Deze optie kan meerdere keren worden gebruikt om meerdere contextstrings te leveren. De contextinformatie helpt de vertaalmachine 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 omringende vertaalde blokken dat als referentiecontext wordt meegegeven bij het opnieuw vertalen van gewijzigde blokken (standaard 2). De context omvat ook de ruwe brontekst rond het gewijzigde gebied (koppen, lijststructuur, bijschriften) en, indien beschikbaar, de vorige versie van de gewijzigde tekst die uit de cache is hersteld, zodat ongewijzigde formuleringen behouden blijven. Stel in op 0 om contextbewuste vertaling volledig uit te schakelen. Merk op dat elk gewijzigd gebied in een eigen API-aanroep wordt vertaald en dat de context tot ongeveer 8000 tekens aan de systeemprompt kan toevoegen, dus contextbewuste vertaling ruilt enige extra kosten in 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 het nieuwe nummer met die van het vorige nummer, zodat ongewijzigde alinea's niet opnieuw worden vertaald en bewerkte alinea's de formulering van het vorige nummer behouden. De seed wordt alleen gebruikt wanneer de doelcache leeg is; anders wordt deze genegeerd met een waarschuwing. Met de standaard 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 strings voordat ze naar de vertaal-API worden verzonden, en herstel ze in de uitvoer. Het woordenlijstbestand geeft één item per invoer: in JSON (canoniek, door machines te genereren)

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

of in een eenvoudige regelindeling (C<category pattern>, C</.../> voor regex). Elk item wordt vervangen door een categorietag zoals C<< <person id=1 /> >>; dezelfde string 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 herstelde platte tekst op: het doel van verbergen is alleen API-verzending.

Een woordenlijst kan worden gegenereerd door een extern hulpmiddel -- 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 de front-matter-regelindeling mogen alleen een afsluitende opmerking op hun eigen regel hebben, niet na de waarde.

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

Verzamel anonimiseringsitems uit inline markeringen in het document zelf. Markeer de eerste voorkomen zoals C<{{ person("山田太郎") }}> en elke voorkomen van de string in het hele document wordt 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 macro C<person> om de naam af te drukken of te redigeren). Een aangepaste I<regex> moet benoemde captures C<< (?<category>...) >> en C<< (?<text>...) >> bevatten.

Merk op dat bij een optie met een optionele waarde zoals deze, een volgend bestandsargument als de waarde zou worden opgevat: schrijf C<--xlate-anonymize-mark=> (met een afsluitende C<=>) wanneer u de standaardnotatie gebruikt.

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

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

Behandel sjabloonexpressies (standaard: Jinja2 C<{{ ... }}>, C<{% ... %}>, C<{# ... #}>) als ondoorzichtige placeholders: instrueer het model om ze ongewijzigd te kopiëren en verifieer per blok dat het antwoord exact dezelfde expressies bevat, elk hetzelfde aantal keren. Hun volgorde mag veranderen, omdat vertaling ze legitiem kan herordenen om de woordvolgorde van de doeltaal te volgen. Een kapotte expressie breekt de uitvoering af; de cache wordt gecheckpoint en bevroren, zodat niets waarvoor is betaald verloren gaat.

Merk op dat bij een optie met een optionele waarde zoals deze een volgend bestandsargument als de waarde zou worden genomen: schrijf C<--xlate-template=> (met een afsluitende C<=>) wanneer u de standaardnotatie gebruikt.

=item B<--xlate-frontmatter>

Behandel een leidend C<---> ... C<--->-blok als YAML-front matter: sluit het uit van vertaling en van de fase-2-contextsegmenten, 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 aan de kant van verhulling wordt vergist).

Laat altijd een lege regel staan na de afsluitende C<--->. Bij een alinea-achtig matchpatroon vormt front matter die direct in de hoofdtekst overgaat één overlappend blok dat de uitsluiting niet kan onderdrukken (in dat geval wordt een waarschuwing afgedrukt); de waarden worden nog steeds geanonimiseerd, maar de front matter zelf zou voor vertaling worden verzonden.

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

Geef een woordenlijst-ID op die voor vertaling wordt gebruikt. Deze optie is alleen beschikbaar bij gebruik van de DeepL-engine. De woordenlijst-ID moet uit uw DeepL-account worden verkregen en zorgt voor consistente vertaling van specifieke termen.

=item B<--xlate-dryrun>

Roep de vertaal-API niet aan; toon in plaats daarvan, via de voortgangsweergave, elke payload precies zoals die zou worden verzonden (na anonimisering en masking). Handig om te controleren wat de machine verlaat en om de kosten van een run 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 getoond zoals verzonden, na anonimisering en masking.

=item B<--xlate-stripe>

Gebruik de module L<App::Greple::stripe> om het overeenkomende deel te tonen met zebra-achtige arcering. Dit is handig wanneer de overeenkomende delen rug-aan-rug zijn verbonden.

Het kleurenpalet wordt geschakeld volgens de achtergrondkleur van de terminal. Als u het expliciet wilt opgeven, kunt u B<--xlate-stripe-light> of B<--xlate-stripe-dark> gebruiken.

=item B<--xlate-mask>

Voer de maskeringsfunctie uit en geef de geconverteerde tekst weer zoals die is, zonder herstel.

=item B<--match-all>

Stel de volledige tekst van het bestand in als doelgebied.

=item B<--lineify-cm>

=item B<--lineify-colon>

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

In de huidige implementatie worden, als meerdere delen van een regel worden vertaald, deze als zelfstandige regels uitgegeven.

=back

=head1 CACHE OPTIONS

De module B<xlate> kan gecachete vertalingstekst per bestand opslaan en vóór uitvoering inlezen om de overhead van het vragen aan de server te elimineren. Met de standaardcache-strategie C<auto> wordt cachedata alleen onderhouden wanneer het cachebestand voor het doelfile bestaat.

Gebruik B<--xlate-cache=clear> om cachebeheer te initiëren of om alle bestaande cachedata op te schonen. Na eenmaal met deze optie te zijn uitgevoerd, wordt een nieuw cachebestand aangemaakt als er nog geen bestaat en daarna automatisch 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 cachebestand aan en sluit af.

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

Houd de cache toch bij zolang het doel een normaal bestand is.

=item C<clear>

Maak eerst de cachedata leeg.

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

Gebruik nooit een cachebestand, zelfs niet als het bestaat.

=item C<accumulate>

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

=back

=item B<--xlate-update>

Deze optie dwingt een update van het cachebestand af, zelfs als dat niet nodig is.

=back

=head1 COMMAND LINE INTERFACE

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

De C<xlate>-opdracht 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 commando C<xlate> werkt samen met de Docker-omgeving, dus ook als je niets lokaal hebt geïnstalleerd, kun je het gebruiken zolang Docker beschikbaar is. Gebruik de optie C<-D> of C<-C>.

Docker-bewerkingen worden afgehandeld door L<App::dozo>, dat ook als zelfstandige opdracht kan worden gebruikt. De opdracht C<dozo> ondersteunt het configuratiebestand C<.dozorc> voor persistente containerinstellingen.

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

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

Uitvoeren zoals C<xlate -C> start een shell met de huidige werkende git-repository gemount.

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

=head1 EMACS

Laad het bestand F<xlate.el> in de repository om het commando C<xlate> vanuit de Emacs-editor te gebruiken. De functie C<xlate-region> vertaalt de opgegeven regio. De standaardtaal is C<EN-US> en je kunt een taal opgeven door het met een prefix-argument aan te roepen.

=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 je authenticatiesleutel in voor de DeepL-service.

=item OPENAI_API_KEY

OpenAI-authenticatiesleutel, gebruikt door de legacy 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 ook.

=item GREPLE_XLATE_CACHE

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

=back

=head1 INSTALL

=head2 CPANMINUS

    $ cpanm App::Greple::xlate

=head2 TOOLS

Installeer het commandoregelhulpmiddel voor de engine die je gebruikt: C<llm> voor de B<gpt5>-engine, C<deepl> voor DeepL, C<gpty> voor de legacy 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 die door xlate wordt gebruikt voor containeroperaties

=head2 RELATED MODULES

=over 2

=item * L<App::Greple>

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

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

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

=item * L<App::sdif>

Gebruik B<sdif> om het conflictmarkeerformaat naast elkaar te tonen met de optie B<-V>.

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

Greple B<stripe>-module gebruikt met de optie B<--xlate-stripe>.

=back

=head2 RESOURCES

=over 2

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

Docker-containerimage.

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

De bibliotheek C<getoptlong.sh> die wordt gebruikt voor het parseren van opties in het script C<xlate> 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 commandoregelinterface

=back

=head2 ARTICLES

=over 2

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

Greple-module om alleen de noodzakelijke delen te vertalen en te vervangen met de DeepL-API (in het Japans)

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

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

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

Automatische vertaal-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
