=encoding utf-8

=head1 NAME

App::Greple::xlate - tõlke tugimoodul greple jaoks

=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> moodul leiab soovitud tekstiplokid ja asendab need tõlgitud tekstiga. Peamine mootor on GPT-5.5 (F<llm/gpt5.pm>), mis kutsub käsku L<llm|https://llm.datasette.io/>; samuti on kaasas DeepL (F<deepl.pm>) ja pärandmootorid, mis põhinevad B<gpty>-l.

Tõlked salvestatakse vahemällu failipõhiselt, nii et käsu uuesti käivitamine ei maksa muutmata teksti puhul midagi. Kui dokumenti redigeeritakse, saadetakse API-le uuesti ainult muudetud lõigud; kontekstiteadlik mootor saab ka ümbritsevad tõlked, muudatuse ümber oleva töötlemata lähteteksti ja redigeeritud lõigu eelmise versiooni, nii et uus tõlge säilitab väljakujunenud sõnastuse (vt B<--xlate-context-window>). Tundlikke stringe saab enne edastamist varjata (vt L</ANONYMIZATION AND TEMPLATES>).

Kui soovite tõlkida tavalisi tekstiplokke dokumendis, mis on kirjutatud Perli pod-stiilis, kasutage käsku B<greple> koos C<--xlate-engine gpt5> ja mooduliga C<perl> järgmiselt:

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

Selles käsus tähendab mustrijada C<^([\w\pP].*\n)+> järjestikuseid ridu, mis algavad tähtnumbrilise ja kirjavahemärgi märgiga. See käsk näitab tõlkimiseks valitud ala esiletõstetuna. Valikut B<--all> kasutatakse kogu teksti kuvamiseks.

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

Seejärel lisage valik C<--xlate>, et tõlkida valitud ala. Seejärel leiab see soovitud jaotised ja asendab need tõlkemootori väljundiga.

Vaikimisi prinditakse originaal ja tõlgitud tekst „konfliktimärgi” vormingus, mis on ühilduv L<git(1)>-ga. Kasutades vormingut C<ifdef>, saate soovitud osa hõlpsasti kätte käsuga L<unifdef(1)>. Väljundvormingut saab määrata valikuga 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>

Kui soovite tõlkida kogu teksti, kasutage valikut B<--match-all>. See on otsetee mustri C<(?s).+> määramiseks, mis vastab kogu tekstile.

Konfliktimärgi vormingu andmeid saab vaadata kõrvuti stiilis käsuga L<sdif|App::sdif> koos valikuga C<-V>. Kuna üksikute stringide kaupa võrdlemisel pole mõtet, on soovitatav valik C<--no-cdif>. Kui te ei pea teksti värvima, määrake C<--no-textcolor> (või 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

Töötlemine toimub määratud ühikutes, kuid mitme järjestikuse tühjade ridadeta tekstiridade korral ühendatakse need koos üheks reaks. See toiming tehakse järgmiselt:

=over 2

=item *

Eemaldage iga rea algusest ja lõpust tühikud.

=item *

Kui rida lõpeb täislaiuses kirjavahemärgiga, liidetakse järgmise reaga.

=item *

Kui rida lõpeb täislaiuses märgiga ja järgmine rida algab täislaiuses märgiga, liidetakse read.

=item *

Kui kas rea lõpp või algus ei ole täislaiuses märk, ühendage need, lisades tühiku.

=back

Puhvriandmeid hallatakse normaliseeritud teksti alusel, seega isegi kui tehakse muudatusi, mis ei mõjuta normaliseerimise tulemust, jäävad puhverdatud tõlkeandmed kehtima.

See normaliseerimisprotsess tehakse ainult esimesele (0.) ja paarisnumbrilistele mustritele. Seega, kui on määratud kaks mustrit järgmiselt, töödeldakse esimesele mustrile vastav tekst pärast normaliseerimist ning teisele mustrile vastava teksti puhul normaliseerimist ei tehta.

    greple -Mxlate -E normalized -E not-normalized

Seetõttu kasutage esimest mustrit teksti jaoks, mida tuleb töödelda mitme rea ühendamisega üheks reaks, ja teist mustrit eelformindatud teksti jaoks. Kui esimesele mustrile ei vasta ühtegi teksti, kasutage mustrit, mis millelegi ei vasta, näiteks C<(?!)>.

=head1 MASKING

Mõnikord on tekstis osasid, mida te ei soovi tõlkida. Näiteks sildid markdown-failides. DeepL soovitab sellistel juhtudel tõlkimisest välja jäetav osa teisendada XML-siltideks, lasta see läbi tõlke ja taastada pärast tõlkimise lõppu. Selle toetamiseks on võimalik määrata osad, mis tuleb tõlkimise eest maskeerida.

    --xlate-setopt maskfile=MASKPATTERN

See tõlgendab faili iga rida C<MASKPATTERN> kui regulaaravaldis, tõlgib sellega vastavad stringid ja taastab algse oleku pärast töötlemist. Ridu, mis algavad C<#>, eiratakse.

Keerukat mustrit saab kirjutada mitmele reale, kasutades tagurpidi kaldkriipsuga paojärjestatud reavahetust.

Kuidas tekst maskeerimise käigus muundatakse, on nähtav valikuga B<--xlate-mask>.

Maskeerimine kaitseb märgistust tõlkimise eest. Tundlike stringide peitmiseks tõlketeenuse enda eest vt L</ANONYMIZATION AND TEMPLATES>; mõlemat saab kasutada koos.

See liides on eksperimentaalne ja võib tulevikus muutuda.

=head1 ANONYMIZATION AND TEMPLATES

Tundlikud stringid saab peita enne nende saatmist tõlke-API-sse ja väljundis taastada. Saadaval on kolm anonüümimisreeglite allikat: sõnastikufail (B<--xlate-anonymize>), dokumendis endas olevad reasisesed märgid (B<--xlate-anonymize-mark>) ja YAML-i front matter väärtused (B<--xlate-frontmatter>). Iga string asendatakse edastamise ajal kategooriasildiga, näiteks C<< <person id=1 /> >>. Peitmise sihtmärk on ainult API-edastus: kohalikud vahemälufailid salvestavad taastatud lihtteksti. Kasutage käsku B<--xlate-dryrun>, et kontrollida täpselt, mida edastataks.

Vormidokumentide (kvartaliaruanded ja muu sarnane) puhul määratlege osalised kohe alguses ja viidake neile põhitekstis:

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

Tõlkige mall iga keele jaoks üks kord käsuga C<--xlate-template> (ja C<--xlate-frontmatter>, kui väärtused hoitakse failis), seejärel renderdage iga juhtum B<pandoc-embedz> eraldiseisvas režiimis -- välises konfiguratsioonis C<global:> all olevad väärtused ei jõua tõlke-API-sse üldse:

    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

Reasiseste märgendite puhul võimaldab makrodefinitsiooni konfiguratsiooni andmine samal tõlgitud mallil renderduda kas pärisnimedega või redigeeritud versioonina:

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

Välistage embedz-plokid tõlkimisest, kui dokument neid sisaldab:

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

Käivitab tõlkeprotsessi iga vaste piirkonna jaoks.

Ilma selle valikuta käitub B<greple> nagu tavaline otsingukäsk. Nii saate enne tegeliku töö käivitamist kontrollida, milline faili osa läheb tõlkimisele.

Käsu tulemus läheb standardsesse väljundisse, seega suunake vajadusel faili või kaaluge mooduli L<App::Greple::update> kasutamist.

Valik B<--xlate> kutsub välja valiku B<--xlate-color> koos valikuga B<--color=never>.

Valikuga B<--xlate-fold> murtakse teisendatud tekst etteantud laiusele. Vaikelaius on 70 ja seda saab määrata valikuga B<--xlate-fold-width>. Neli veergu on reserveeritud jooksva sisestuse jaoks, seega mahub igale reale maksimaalselt 74 märki.

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

Määrab kasutatava tõlkemootori.

Praegu on saadaval järgmised mootorid

=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

Mootorimooduleid otsitakse esmalt taustsüsteemi nimeruumidest (C<llm>, seejärel C<gpty>), seejärel otse C<App::Greple::xlate> alt. Seega C<gpt5> laadib C<App::Greple::xlate::llm::gpt5>, mis kutsub käsku C<llm>, samas kui C<gpt4o> langeb tagasi C<App::Greple::xlate::gpty::gpt4o> peale. Kasutage C<--xlate-setopt backend=gpty>, et sundida kasutama konkreetset taustsüsteemi.

=item B<--xlate-labor>

=item B<--xlabor>

Tõlkemootori kutsumise asemel eeldatakse, et teete töö ise. Pärast tõlgitava teksti ettevalmistamist kopeeritakse need lõikepuhvrisse. Eeldatakse, et kleebite need vormi, kopeerite tulemuse lõikepuhvrisse ja vajutate Enter.

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

Määrake sihtkeel. LLM-mootorid aktsepteerivad mis tahes keelenime või -koodi, mida mudel mõistab; see interpoleeritakse tõlkeviipa. Saadavalolevaid keeli saate C<deepl languages> käsuga, kui kasutate mootorit B<DeepL>.

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

Originaalteksti jaoks kasutatav silt väljundvormingutes C<conflict>, C<colon> ja C<ifdef>. Mootori B<DeepL> puhul edastatakse mittevaikeväärtus ka lähtekeelena.

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

Määrake originaal- ja tõlketeksti väljundvorming.

Järgnevad vormingud peale C<xtxt> eeldavad, et tõlgitav osa on ridade kogum. Tegelikult on võimalik tõlkida ainult osa reast, kuid muu kui C<xtxt> vormingu määramine ei anna mõtestatud tulemust.

=over 4

=item B<conflict>, B<cm>

Algne ja teisendatud tekst prinditakse L<git(1)> konfliktimarkerite vormingus.

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

Algse faili saate taastada järgmise käsuga L<sed(1)>.

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

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

Algne ja tõlgitud tekst väljastatakse markdown’i kohandatud konteineri stiilis.

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

Ülaltoodud tekst teisendatakse HTML-is järgnevaks.

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

Koolonite arv on vaikimisi 7. Kui määrate koolonite jada nagu C<:::::>, kasutatakse seda 7 kooloni asemel.

=item B<ifdef>

Algne ja teisendatud tekst prinditakse vormingus L<cpp(1)> C<#ifdef>.

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

Ainult jaapanikeelse teksti saate kätte käsuga B<unifdef>:

    unifdef -UORIGINAL -DJA foo.ja.pm

=item B<space>

=item B<space+>

Algne ja teisendatud tekst prinditakse, eraldatuna ühe tühja reaga. C<space+> korral väljastatakse teisendatud teksti järel ka reavahetus.

=item B<xtxt>

Kui vorming on C<xtxt> (tõlgitud tekst) või tundmatu, prinditakse ainult tõlgitud tekst.

=back

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

Määra maksimaalne teksti pikkus, mis korraga API-le saadetakse. Vaikeväärtus 0 tähendab mootori enda piirangut: DeepL tasuta konto teenuse puhul on see 128K API jaoks (B<--xlate>) ja 5000 lõikepuhvri liidese jaoks (B<--xlate-labor>). Kui kasutad Pro-teenust, võid neid väärtusi muuta.

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

Määra maksimaalne ridade arv, mis korraga API-le saadetakse.

Sea see väärtus 1, kui soovid tõlkida ühe rea kaupa. See valik on ülimuslik valiku C<--xlate-maxlen> suhtes.

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

Määrake tõlkemootorile saadetav kohandatud viip. See valik on saadaval LLM-mootorite (C<gpt3>, C<gpt4o>, C<gpt5>) jaoks, kuid mitte DeepL-i jaoks. Saate tõlkekäitumist kohandada, andes tehisintellekti mudelile konkreetsed juhised. Kui viip sisaldab C<%s>, asendatakse see sihtkeele nimega.

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

Määra täiendav kontekstiinfo, mis saadetakse tõlkemootorile. Seda valikut saab kasutada mitu korda, et edastada mitu kontekstistringi. Kontekst aitab tõlkemootoril tausta mõista ja anda täpsemaid tõlkeid.

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

(Context-aware engines only, e.g. C<gpt5> on the llm backend)
Ümbritsevate tõlgitud plokkide arv, mis antakse muudetud plokkide uuesti tõlkimisel viitekontekstina (vaikimisi 2). Kontekst sisaldab ka muudetud piirkonda ümbritsevat toorest lähteksti (pealkirjad, loendistruktuur, pildiallkirjad) ning võimaluse korral vahemälust taastatud muudetud teksti eelmist versiooni, et muutmata sõnastus säiliks. Määrake väärtuseks 0, et kontekstiteadlik tõlge täielikult keelata. Pange tähele, et iga muudetud piirkond tõlgitakse eraldi API-kutses ja kontekst võib süsteemiviibale lisada kuni umbes 8000 märki, seega vahetab kontekstiteadlik tõlge järjepidevuse nimel mõningase lisakulu vastu.

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

Lähtesta uue dokumendi vahemälu teise dokumendi vahemälufailist. Kasulik perioodiliste aruannete puhul: külva uue väljaande vahemälu eelmise väljaande omaga, et muutmata lõike ei tõlgitaks uuesti ja muudetud lõigud säilitaksid eelmise väljaande sõnastuse. Seemet kasutatakse ainult siis, kui sihtvahemälu on tühi; vastasel juhul eiratakse seda hoiatusega. Vaikimisi C<--xlate-cache=auto> korral tähendab seemne määramine ka uue dokumendi vahemälufaili loomist.

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

Anonümiseeri tundlikud stringid enne nende saatmist tõlke-API-le ja taasta need väljundis. Sõnastikufail annab iga üksuse kohta ühe kirje: JSON-is (kanoniline, masinaga genereeritav)

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

või lihtsas reaformaadis (C<category pattern>, C</.../> regexi jaoks). Iga üksus asendatakse kategooriasildiga, näiteks C<< <person id=1 /> >>; sama string saab alati sama sildi, nii et mudel saab jälgida, kes on kes. Tundmatuid JSON-välju eiratakse, seega võivad generaatorid (nt kohalik LLM, mis ekstraheerib olemeid) lisada oma annotatsioone. Kategooria C<lit> on reserveeritud. Kohalikud vahemälufailid talletavad endiselt taastatud lihtteksti: varjamise siht on ainult API-edastus.

Sõnastiku saab genereerida välise tööriistaga -- näiteks kohalik mudel, mis ekstraheerib tundlikke olemeid:

    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 ...

Failis olev UTF-8 BOM on lubatud. Front matter'i reaformaadis võivad väärtustel olla lõpus kommentaarid ainult eraldi real, mitte väärtuse järel.

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

Kogu anonümiseerimiskirjed dokumendi enda sisestest märgetest. Märgi esimene esinemine kujul C<{{ person("山田太郎") }}> ja iga selle stringi esinemine kogu dokumendis anonümiseeritakse. Märge ise jääb lähtekoodi ja tõlkesse, nii et dokumenti saab töödelda ka Jinja2-stiilis makrotöötlejaga (määratle makro C<person>, et nimi printida või redigeerida). Kohandatud I<regex> peab sisaldama nimega hõiveid C<< (?<category>...) >> ja C<< (?<text>...) >>.

Pange tähele, et sellise valikulise väärtusega valiku korral võetaks järgnev failiargument väärtuseks: kirjutage C<--xlate-anonymize-mark=> (lõpus oleva C<=>-ga), kui kasutate vaikimisi märgistust.

Alternatiivseid märgistusi saab konfigureerida, näiteks C<< --xlate-anonymize-mark='@@(?<category>[a-z][a-z0-9_]*):(?<text>[^\n]+?)@@' >> C<@@person:NAME@@>-stiilis märgete jaoks, või HTML-kommentaari vormi, mis jääb renderdatud Markdownis nähtamatuks. Märkereeglid kogutakse dokumendipõhiselt: ühes sisendfailis märgitud stringi ei varjata sama käivituse teises failis (erinevalt front matter'i väärtustest, mis kogunevad failide vahel).

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

Käsitle malliväljendeid (vaikimisi: Jinja2 C<{{ ... }}>, C<{% ... %}>, C<{# ... #}>) läbipaistmatute kohatäitjatena: juhenda mudelit neid muutmata kopeerima ja kontrolli iga ploki kohta, et vastus sisaldaks täpselt samu väljendeid, igaüht sama arv kordi. Nende järjekord võib muutuda, sest tõlkimisel järjestatakse need õigustatult ümber, et järgida sihtkeele sõnajärge. Katkine väljend katkestab käivituse; vahemälu salvestatakse kontrollpunktina ja külmutatakse, nii et midagi tasulist kaotsi ei lähe.

Pange tähele, et sellise valikulise väärtusega valiku korral võetaks järgnev failargument väärtusena: kasutage vaikemärgistuse korral C<--xlate-template=> (lõpus oleva C<=>-ga).

=item B<--xlate-frontmatter>

Käsitle alguses olevat C<---> ... C<---> plokki YAML-i esiosana: jäta see tõlkimisest ja 2. faasi kontekstilõikudest välja ning lisa selle lamedad C<key: value> väärtused anonüümimisreeglitesse (kategooria C<var>) turvavõrguna. Mitme sisendfaili korral kogutud väärtused kuhjuvad (pigem varjamise kasuks eksides).

Jäta alati tühi rida pärast sulgevat C<--->. Lõigustiilis vastemustriga moodustab otse põhitekstiga kokku jooksev esiosa ühe üle piiri ulatuva ploki, mida välistamine ei suuda maha suruda (sellisel juhul prinditakse hoiatus); väärtused anonüümitakse siiski, kuid esiosa ise saadetaks tõlkimiseks.

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

Määra sõnastiku ID, mida tõlkimisel kasutada. See valik on saadaval ainult DeepL mootori kasutamisel. Sõnastiku ID tuleb hankida oma DeepL kontolt ning see tagab kindlate terminite ühtlase tõlke.

=item B<--xlate-dryrun>

Ära kutsu tõlke-API-t; selle asemel näita edenemiskuva kaudu iga payload täpselt sellisena, nagu see edastataks (pärast anonüümimist ja maskimist). Kasulik kontrollimaks, mis masinast väljub, ning käivituse maksumuse hindamiseks.

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

Vaata tõlketulemust reaalajas STDERR-väljundis. C<From> payload kuvatakse edastatud kujul, pärast anonüümimist ja maskimist.

=item B<--xlate-stripe>

Kasuta moodulit L<App::Greple::stripe>, et näidata sobitatud osa sebramustriga. See on kasulik, kui sobitatud osad paiknevad vahetult üksteise järel.

Värvipalett lülitub vastavalt terminali taustavärvile. Kui soovid seda selgesõnaliselt määrata, võid kasutada B<--xlate-stripe-light> või B<--xlate-stripe-dark>.

=item B<--xlate-mask>

Tee maskimine ja kuva teisendatud tekst taastamata kujul.

=item B<--match-all>

Sea kogu faili tekst sihtalaks.

=item B<--lineify-cm>

=item B<--lineify-colon>

Vormingute C<cm> ja C<colon> puhul jagatakse väljund ridade kaupa ja vormindatakse vastavalt. Seetõttu ei saa oodatud tulemust, kui tõlgitakse ainult osa reast. Need filtrid parandavad väljundi, mis on rikutud rea osalise tõlkimise tõttu, viies selle normaalse reahaaval väljundi kujule.

Praeguses teostuses, kui ühest reast tõlgitakse mitu osa, väljastatakse need sõltumatute ridadena.

=back

=head1 CACHE OPTIONS

Moodul B<xlate> saab talletada iga faili tõlke puhverdatud teksti ja lugeda selle enne täitmist, et vältida päringute esitamise ülekulu serverile. Vaikimisi puhverdamisstrateegia C<auto> korral hoitakse puhvriandmeid ainult siis, kui sihtfaili jaoks on olemas puhverfail.

Kasuta B<--xlate-cache=clear>, et algatada puhvri haldus või puhastada kogu olemasolev puhvriandmestik. Kui see valik on korra käivitatud, luuakse uus puhverfail, kui seda ei ole, ja seda hallatakse edaspidi automaatselt.

=over 7

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

=over 4

=item C<auto> (Default)

Säilita puhverfail, kui see eksisteerib.

=item C<create>

Loo tühi puhverfail ja välju.

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

Säilita vahemälu igal juhul, kui siht on tavaline fail.

=item C<clear>

Tühjenda esmalt vahemälu andmed.

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

Ära kasuta vahemälufaili isegi siis, kui see olemas on.

=item C<accumulate>

Vaikimisi eemaldatakse kasutamata andmed vahemälufailist. Kui sa ei soovi neid eemaldada ja tahad faili alles jätta, kasuta C<accumulate>.

=back

=item B<--xlate-update>

See valik sunnib vahemälufaili uuendama isegi siis, kui see pole vajalik.

=back

=head1 COMMAND LINE INTERFACE

Seda moodulit saab hõlpsasti kasutada käsurealt, kasutades levitusega kaasas olevat käsku C<xlate>. Vaata kasutusjuhiseid man-lehelt C<xlate>.

Käsk C<xlate> toetab GNU-stiilis pikki valikuid nagu C<--to-lang>, C<--from-lang>, C<--engine> ja C<--file>. Kasuta C<xlate -h> kõigi saadaolevate valikute nägemiseks.

Käsk C<xlate> töötab kooskõlas Dockeri keskkonnaga, seega isegi kui sul pole midagi lokaalselt paigaldatud, saad seda kasutada seni, kuni Docker on saadaval. Kasuta valikut C<-D> või C<-C>.

Dockeri toiminguid haldab L<App::dozo>, mida saab kasutada ka iseseisva käsuna. Käsk C<dozo> toetab püsivate konteineri sätete jaoks konfiguratsioonifaili C<.dozorc>.

Samuti, kuna on pakutud mitmesuguste dokumendistiilide makefile’e, on tõlkimine teistesse keeltesse võimalik ilma erisäteteta. Kasuta valikut C<-M>.

Võid kombineerida ka Docker ja C<make> valikud, et käitada C<make> Dockeri keskkonnas.

Käivitamine kujul C<xlate -C> avab shelli, kus jooksev töökoopia git-repositoorium on ühendatud.

Loe üksikasju jaapani artiklist jaotisest L</SEE ALSO>.

=head1 EMACS

Laadi repositooriumis olev F<xlate.el> fail, et kasutada Emacsis käsku C<xlate>. Funktsioon C<xlate-region> tõlgib etteantud piirkonna. Vaikimisi keel on C<EN-US> ning keelt saab määrata seda prefiksargumendiga kutsudes.

=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

Sea oma DeepL teenuse autentimisvõti.

=item OPENAI_API_KEY

OpenAI autentimisvõti, mida kasutavad pärand-B<gpty> mootorid. C<llm>-põhine B<gpt5> mootor loeb samuti seda muutujat, kuid töötavad ka võtmed, mis on salvestatud käsuga C<llm keys set openai>.

=item GREPLE_XLATE_CACHE

Sea vaikimisi vahemälustrateegia (vt L</CACHE OPTIONS>).

=back

=head1 INSTALL

=head2 CPANMINUS

    $ cpanm App::Greple::xlate

=head2 TOOLS

Paigalda kasutatava mootori käsurea tööriist: C<llm> B<gpt5> mootori jaoks, C<deepl> DeepL-i jaoks, C<gpty> pärand-GPT mootorite jaoks.

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> - xlate’i poolt konteineri toiminguteks kasutatav üldine Dockeri käitaja

=head2 RELATED MODULES

=over 2

=item * L<App::Greple>

Vaata sihtteksti mustri üksikasju käsiraamatust B<greple>. Kasuta valikuid B<--inside>, B<--outside>, B<--include>, B<--exclude> vastendusala piiramiseks.

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

Saad kasutada moodulit C<-Mupdate>, et muuta faile käsu B<greple> tulemuste põhjal.

=item * L<App::sdif>

Kasuta B<sdif>, et näidata konfliktimärgendite formaati kõrvuti valikuga B<-V>.

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

Greple B<stripe> moodulit kasutatakse valikuga B<--xlate-stripe>.

=back

=head2 RESOURCES

=over 2

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

Dockeri konteineripilt.

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

C<getoptlong.sh> teek, mida kasutatakse valikute parsimiseks skriptis C<xlate> ja L<App::dozo>.

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

Käsk C<llm>, mida mootor B<gpt5> kasutab LLM-mudelitele juurdepääsuks.

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

DeepL Python’i teek ja CLI käsk.

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

OpenAI Python’i teek

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

OpenAI käsurea liides

=back

=head2 ARTICLES

=over 2

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

Greple moodul vajalike osade tõlkimiseks ja asendamiseks ainult DeepL API-ga (jaapani keeles)

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

Dokumentide genereerimine 15 keeles DeepL API mooduliga (jaapani keeles)

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

Automaatse tõlke Docker-keskkond DeepL API-ga (jaapani keeles)

=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
