calibre - en to nl translation catalogue (103 entries)

en: Setting up a calibre development environment
nl: Opzetten van Calibre in een development omgeving

en: calibre is completely open source, licensed under the `GNU GPL v3 <https://www.gnu.org/licenses/gpl.html>`_. This means that you are free to download and modify the program to your heart's content. In this section, you will learn how to get a calibre development environment set up on the operating system of your choice. calibre is written primarily in `Python <https://www.python.org>`_ with some C/C++ code for speed and system interfacing. Note that calibre requires at least Python 3.8.
nl: calibre is volledig open source, onder de `GNU GPL v3 licentie <https://www.gnu.org/licenses/gpl.html>` _. Dit betekent dat u vrij bent om het programma naar hartenlust te downloaden en aan te passen. In dit gedeelte leert u hoe u een calibre ontwikkelingsomgeving kunt opzetten voor het besturingssysteem van uw keuze. calibre wordt voornamelijk geschreven in `Python <https://www.python.org>` _ met wat C/C++ code voor snelheid en systeeminterface. Merk op dat calibre minstens Python 3.8 nodig heeft.

en: Contents
nl: Inhoud

en: Design philosophy
nl: Ontwerp filosofie

en: calibre has its roots in the Unix world, which means that its design is highly modular. The modules interact with each other via well defined interfaces. This makes adding new features and fixing bugs in calibre very easy, resulting in a frenetic pace of development. Because of its roots, calibre has a comprehensive command line interface for all its functions, documented in :doc:`generated/en/cli-index`.
nl: Calibre heeft zijn wortels in de Unix-wereld, wat betekent dat het design bijzonder modulair is. De modules werken samen met elkaar via precies gedefinieerde interfaces. Hierdoor wordt het toevoegen van nieuwe features en het oplossen van bugs in Calibre erg eenvoudig, wat resulteert in een snel ontwikkelingstempo. Vanwege deze wortels heeft Calibre een uitgebreide command line interface voor al zijn functies, welke gedocumenteerd zijn in  :doc:`generated/nl/cli-index`.

en: Code layout
nl: Code opmaak

en: All the calibre Python code is in the ``calibre`` package. This package contains the following main sub-packages
nl: Alle  de Calibre python code staat in het ``Calibre`` pakket. Dit pakket bevat de volgende hoofddeel pakketten

en: devices - All the device drivers. Just look through some of the built-in drivers to get an idea for how they work.
nl: apparaten - Alle apparaatstuurprogramma's. Bekijk enkele van de ingebouwde stuurprogramma's om een ​​idee te krijgen hoe ze werken.

en: For details, see: ``devices.interface`` which defines the interface supported by device drivers and ``devices.usbms`` which defines a generic driver that connects to a USBMS device. All USBMS based drivers in calibre inherit from it.
nl: Voor details, bekijk: ``devices.interface`` wat de interface definieert ondersteund door toestel stuurprogramma's en ``devices.usbms`` wat een generiek stuurprogramma definieert die met een USBMS toestel verbindt. Alle USBMS gebaseerde stuurprogramma's erven ervan.

en: e-books  - All the e-book conversion/metadata code. A good starting point is ``calibre.ebooks.conversion.cli`` which is the module powering the :command:`ebook-convert` command. The conversion process is controlled via ``conversion.plumber``. The format independent code is all in ``ebooks.oeb`` and the format dependent code is in ``ebooks.format_name``.
nl: e-boeken  - Alle e-boek conversie/metadata code. Een goed beginpunt is ``calibre.ebooks.conversion.cli``, de module die het :command:`ebook-convert` commando drijft. Het conversieproces wordt gecontroleerd via ``conversion.plumber``. De formaat onafhankelijke code zit allemaal in ``ebooks.oeb`` en de formaat afhankelijke code in ``ebooks.format_name``.

en: Metadata reading, writing, and downloading is all in ``ebooks.metadata``
nl: Metadata lezen, schrijven en downloaden staat allemaal in `` ebooks.metagegevans``

en: Conversion happens in a pipeline, for the structure of the pipeline, see :ref:`conversion-introduction`. The pipeline consists of an input plugin, various transforms and an output plugin. The code that constructs and drives the pipeline is in :file:`plumber.py`. The pipeline works on a representation of an e-book that is like an unzipped epub, with manifest, spine, toc, guide, html content, etc. The class that manages this representation is OEBBook in ``ebooks.oeb.base``. The various transformations that are applied to the book during conversions live in :file:`oeb/transforms/*.py`. And the input and output plugins live in :file:`conversion/plugins/*.py`.
nl: Conversie gebeurt in een pijplijn, voor de structuur van de pijplijn, bekijk :ref:`conversion-introduction`. De pijplijn bestaat uit een invoerplug-in, verschillende transforms en een uitvoerplug-in. De code die de pijplijn opbouwt en aandrijft zit in :file:`plumber.py`. De pijplijn werkt op een voorstelling van een e-boek als een ontzipte EPUB, met manifest, spine, ToC, gids, HTML inhoud, enz. De class die deze voorstelling beheert is OEBBook in ``ebooks.oeb.base``. De verschillende transformaties toegepast op het boek tijdens conversie wonen in  :file:`oeb/transforms/*.py`. En de in- en uitvoerplug-in  wonen in :file:`oeb/transforms/*.py`.

en: E-book editing happens using a different container object. It is documented in :ref:`polish_api`.
nl: E-boek bewerken gebeurt met een ander container object, gedocumenteerd in :ref:`polish_api`.

en: db - The database back-end. See :ref:`db_api` for the interface to the calibre library.
nl: db - De database achterkant. Bekijk :ref:`db_api` voor de interface naar de calibre bibliotheek.

en: Content server: ``srv`` is the calibre Content server.
nl: Content server: ``srv`` is de calibre Content server.

en: gui2 - The Graphical User Interface. GUI initialization happens in ``gui2.main`` and ``gui2.ui``. The e-book-viewer is in ``gui2.viewer``. The e-book editor is in ``gui2.tweak_book``.
nl: gui2 - De Grafische Gebruiker Interface. GUI initialisatie gebeurt in ``gui2.main`` en ``gui2.ui``. De e-boek-viewer zit in ``gui2.viewer``. De e-book editor in ``gui2.tweak_book``.

en: If you want to locate the entry points for all the various calibre executables, look at the ``entry_points`` structure in `linux.py <https://github.com/kovidgoyal/calibre/blob/master/src/calibre/linux.py>`_.
nl: Als u de ingangspunten voor alle calibre executables wilt lokaliseren, bekijk de ``entry_points`` structuur in `linux.py <https://github.com/kovidgoyal/calibre/blob/master/src/calibre/linux.py>`_.

en: If you need help understanding the code, post in the `development forum <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_ and you will most likely get help from one of calibre's many developers.
nl: Als u hulp nodig hebt om de code te begrijpen, post iets in het `ontwikkelforum <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_ en u zal heel waarschijnlijk hulp krijgen van een van de vele calibre ontwikkelaars.

en: Getting the code
nl: De code verkrijgen

en: You can get the calibre source code in two ways, using a version control system or directly downloading a :website_base:`tarball <dist/src>`.
nl: U kan de calibre broncode op twee manieren krijgen, via een versiecontrolesysteem of download direct een :website_base:`tarball <dist/src>`.

en: calibre uses `Git <https://www.git-scm.com/>`_, a distributed version control system. Git is available on all the platforms calibre supports.  After installing Git, you can get the calibre source code with the command::
nl: calibre gebruikt `Git <https://www.git-scm.com/>`_, een gedistribueerd versiecontrolesysteem. Git is beschikbaar op alle platformen die calibre ondersteunt. Na installeren van Git kan u de calibre source code krijgen met het commando::

en: On Windows you will need the complete path name, that will be something like :file:`C:\\Program Files\\Git\\git.exe`.
nl: Op Windows heb je de volledige padnaam nodig, dat zal ongeveer zo zijn: bestand: `C:\\Program Files\\Git\\git.exe`.

en: calibre is a very large project with a very long source control history, so the above can take a while (10 mins to an hour depending on your internet speed).
nl: Calibre is een zeer groot project met een zeer lange versiebeheergeschiedenis, dus het bovenstaande kan een tijd duren (10 minuten tot een uur, afhankelijk van je internetsnelheid).

en: If you want to get the code faster, the source code for the latest release is always available as an :website_base:`archive <dist/src>`.
nl: Als u de code sneller wilt krijgen, de broncode van de laatste uitgave is altijd beschikbaar als een :website_base:`archive <dist/src>`.

en: To update a branch to the latest code, use the command::
nl: Om een ​​vertakking bij te werken naar de nieuwste code, gebruik de volgende opdracht:

en: You can also browse the code at `GitHub <https://github.com/kovidgoyal/calibre>`_.
nl: U kan ook de code doorbladeren op `GitHub <https://github.com/kovidgoyal/calibre>`_.

en: Submitting your changes to be included
nl: Uw aanpassingen insturen voor productie

en: If you only plan to make a few small changes, you can make your changes and create a "merge directive" which you can then attach to a ticket in the calibre `bug tracker <https://bugs.launchpad.net/calibre>`_. To do this, make your changes, then run::
nl: Als u enkel een paar kleine veranderingen wilt maken, maak uw veranderingen en creëer een "merge directive" die u dan aan een ticket in de calibre `bug tracker <https://bugs.launchpad.net/calibre>`_ kan koppelen. Om dit te doen, maak uw veranderingen , draai dan::

en: This will create a :file:`my-changes` file in the current folder, simply attach that to a ticket on the calibre `bug tracker <https://bugs.launchpad.net/calibre>`_. Note that this will include *all* the commits you have made. If you only want to send some commits, you have to change ``origin/master`` above. To send only the last commit, use::
nl: Dit creëert een :file:`my-changes` bestand in de huidige map, koppel dit gewoon aan een ticket op de calibre `bug tracker <https://bugs.launchpad.net/calibre>`_. Merk op dat dit *alle* commits die gemaakt hebt meeneemt. Als u slechts enkele commits wil sturen, moet u de ``origin/master`` boven veranderen. Om enkel de laatste commit te sturen, gebruik::

en: To send the last *n* commits, replace *1* with *n*, for example, for the last 3 commits::
nl: Als u de laatste *n* commentaren wilt verzenden, vervangt u *1* door *n*, bijvoorbeeld voor de laatste 3 commentaren::

en: Be careful to not include merges when using ``HEAD~n``.
nl: Zorg dat u geen samenvoegingen opneemt bij het gebruik van ``HEAD~n``.

en: If you plan to do a lot of development on calibre, then the best method is to create a `GitHub <https://github.com>`__ account. Below is a basic guide to setting up your own fork of calibre in a way that will allow you to submit pull requests for inclusion into the main calibre repository:
nl: Als u veel ontwikkelwerk aan calibre wil doen, kan u best een  `GitHub <https://github.com>`__ account creëren. Onder vindt u een basisgids om uw eigen fork van calibre op te zetten die u toelaat pull requests in te dienen voor opname in calibre's hoofdrepository:

en: Setup git on your machine as described in this article: `Setup Git <https://help.github.com/articles/set-up-git>`_
nl: Stel git in op uw machine zoals beschreven in dit artikel: `Setup Git <https://help.github.com/articles/set-up-git>`_

en: Setup ssh keys for authentication to GitHub, as described here: `Generating SSH keys <https://help.github.com/articles/generating-ssh-keys>`_
nl: Stel ssh-sleutels in voor authenticatie naar GitHub, zoals hier beschreven: `SSH-sleutels genereren <https://help.github.com/articles/generating-ssh-keys>` _

en: Go to https://github.com/kovidgoyal/calibre and click the :guilabel:`Fork` button.
nl: Ga naar https://github.com/kovidgoyal/Calibre en klik op de :guilabel:`Fork` button.

en: In a Terminal do::
nl: In een terminalvenster doe::

en: Replace <username> above with your GitHub username. That will get your fork checked out locally.
nl: Vervang <username> boven door uw GitHub gebruikersnaam. Dat zorgt ervoor dat uw fork lokaal wordt uitgecheckt.

en: You can make changes and commit them whenever you like. When you are ready to have your work merged, do a::
nl: U kunt wijzigingen aanbrengen en deze toewijzen wanneer u maar wilt. Wanneer je klaar bent om je werk samen te voegen, doe dan een:

en: and go to ``https://github.com/<username>/calibre`` and click the :guilabel:`Pull Request` button to generate a pull request that can be merged.
nl: en ga naar ``https://github.com/<username>/Calibre`` en klik op :guilabel:`Pull Request` button om een pull request te generen die samengevoegd kan worden.

en: You can update your local copy with code from the main repo at any time by doing::
nl: U kunt uw lokale exemplaar op elk gewenst moment bijwerken met code van de hoofdrepo door te doen:

en: You should also keep an eye on the calibre `development forum <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_. Before making major changes, you should discuss them in the forum or contact Kovid directly (his email address is all over the source code).
nl: U houdt best een oogje op het calibre `ontwikkelforum <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_. Vooraleer grote veranderingen te maken, bespreek ze best in het forum of contacteer Kovid direct (de broncode krioelt van z'n e-mailadres).

en: Windows development environment
nl: Windows ontwikkel omgeving

en: You must also get the calibre source code separately as described above.
nl: U moet ook de calibre broncode apart ophalen zoals beschreven boven.

en: Install calibre normally, using the `Windows installer <https://calibre-ebook.com/download_windows>`__. Then open a Command Prompt and change to the previously checked out calibre code folder. For example::
nl: Installeer calibre normaal met de Windows installer <https://calibre-ebook.com/download_windows>`__. Open dan een Commandoprompt en ga naar de voordien bekeken calibre codemap. Bijvoorbeeld::

en: calibre is the folder that contains the src and resources sub-folders.
nl: calibre is de map die de src bevat en bronnensubmappen.

en: The next step is to set the environment variable ``CALIBRE_DEVELOP_FROM`` to the absolute path of the src folder. So, following the example above, it would be ``C:\Users\kovid\work\calibre\src``. `Here is a short guide <https://docs.python.org/using/windows.html#excursus-setting-environment-variables>`_ to setting environment variables on Windows.
nl: De volgende stap is de omgevingsvariabele ``CALIBRE_DEVELOP_FROM`` instellen op het absolute pad van de src map. Dus, volgens het voorbeeld boven zou het ``C:\Users\kovid\work\calibre\src`` zijn. Hier is een korte gids <https://docs.python.org/using/windows.html#excursus-setting-environment-variables>`_ over instellen van omgevingsvariabelen in Windows.

en: Once you have set the environment variable, open a new command prompt and check that it was correctly set by using the command::
nl: Nadat u de omgevingsvariabele hebt ingesteld, opent u een nieuwe opdrachtprompt en controleert u of deze correct is ingesteld met de opdracht::

en: Setting this environment variable means that calibre will now load all its Python code from the specified location.
nl: Deze omgevingsvariabele instellen betekent dat calibre nu alle Python code vanuit de gespecificeerde locatie laadt.

en: That's it! You are now ready to start hacking on the calibre code. For example, open the file :file:`src\\calibre\\__init__.py` in your favorite editor and add the line::
nl: Das alles! U bent nu klaar om de calibre code te beginnen hacken. Bv. open het bestand :file:`src\\calibre\\__init__.py` in uw favoriete editor en voeg volgende regel toe::

en: near the top of the file. Now run the command :command:`calibredb`. The very first line of output should be ``Hello, world!``.
nl: in de buurt van de bovenkant van het bestand. Voer nu de opdracht: opdracht uit: `calibredb`. De allereerste regel van de uitvoer zou moeten zijn `` Hallo, wereld! ``.

en: You can also setup a calibre development environment inside the free Microsoft Visual Studio, if you like, following the instructions `here <https://www.mobileread.com/forums/showthread.php?t=251201>`_.
nl: U kan ook een calibre ontwikkelomgeving opzetten in het gratis Microsoft Visual Studio, als u wilt, met volgende instructies `hier <https://www.mobileread.com/forums/showthread.php?t=251201>`_.

en: macOS development environment
nl: macOS ontwikkelomgeving

en: Install calibre normally using the `provided .dmg <https://calibre-ebook.com/download_osx>`__. Then open a Terminal and change to the previously checked out calibre code folder, for example::
nl: Installeer calibre normaal met de `provided .dmg <https://calibre-ebook.com/download_osx>`__. Open dan een Terminal en ga naar de voordien bekeken calibre codemap, bijvoorbeeld::

en: calibre is the folder that contains the src and resources sub-folders. The calibre command line tools are found inside the calibre app bundle, in :file:`/Applications/calibre.app/Contents/MacOS` you should add this folder to your PATH environment variable, if you want to run the command line tools easily.
nl: calibre is de map die de src bevat en bronnensubmappen. de calibre opdrachtregelgereedschappen vindt u in de calibre appbundel, in :file:`/Applications/calibre.app/Contents/MacOS`, u voegt deze map best toe aan uw PATH omgevingsvariabele als u de opdrachtregelgereedschappen vlot wilt gebruiken.

en: The next step is to create a bash script that will set the environment variable ``CALIBRE_DEVELOP_FROM`` to the absolute path of the src folder when running calibre in debug mode.
nl: De volgende stap is het maken van een bash-script dat de omgevingsvariabele ``CALIBRE_DEVELOP_FROM`` instelt op het absolute pad van de src map bij het uitvoeren van calibre in foutzoekmodus.

en: Create a plain text file::
nl: Maak een platte-tekst bestand::

en: Save this file as :file:`/usr/local/bin/calibre-develop`, then set its permissions so that it can be executed::
nl: Sla dit bestand op als :file:`/usr/local/bin/calibre-develop`, stel dan de rechten in zodat het kan worden uitgevoerd::

en: Once you have done this, run::
nl: Als u dit heeft gedaan, voer uit::

en: You should see some diagnostic information in the Terminal window as calibre starts up, and you should see an asterisk after the version number in the GUI window, indicating that you are running from source.
nl: U zou wat diagnostische informatie in het Terminal-venster moeten zien als Calibre opstart, en u zou een asterisk na het versienummer in het GUI-venster moeten zien, om aan te geven dat u vanuit de bron loopt.

en: Linux development environment
nl: Linux ontwikkel omgeving

en: calibre is primarily developed on Linux. You have two choices in setting up the development environment. You can install the calibre binary as normal and use that as a runtime environment to do your development. This approach is similar to that used in Windows and macOS. Alternatively, you can install calibre from source. Instructions for setting up a development environment from source are in the INSTALL file in the source tree. Here we will address using the binary as a runtime, which is the recommended method.
nl: calibre is voornamelijk in Linux ontwikkeld. U hebt twee keuzes bij instellen van de ontwikkelomgeving. U kan de calibre binary als gewoonlijk installeren en dat als runtime omgeving gebruiken voor uw ontwikkeling. Deze werkwijze is gelijkaardig aan die in Windows en macOS. Als alternatief kan u calibre van de bron installeren. Instructies om een ontwikkelomgeving op te zetten vanuit de bron staan in het INSTALL bestand in de bestandsboom. Hier gaat het over gebruik van de binary als een runtime, wat de aanbevolen methode is.

en: Install calibre using the `binary installer <https://calibre-ebook.com/download_linux>`_. Then open a terminal and change to the previously checked out calibre code folder, for example::
nl: Installeer calibre met de `binary installer <https://calibre-ebook.com/download_linux>`_. Open dan een Terminal en ga naar de voordien bekeken calibre codemap, bijvoorbeeld::

en: The next step is to set the environment variable ``CALIBRE_DEVELOP_FROM`` to the absolute path of the src folder. So, following the example above, it would be ``/home/kovid/work/calibre/src``. How to set environment variables depends on your Linux distribution and what shell you are using.
nl: De volgende stap is om de omgevingsvariabele `` CALIBRE_DEVELOP_FROM`` in te stellen op het absolute pad van de src-map. Dus, in navolging van het bovenstaande voorbeeld, zou het ``/home/kovid/work/Calibre/src`` zijn. Het instellen van omgevingsvariabelen is afhankelijk van je Linux-distributie en welke shell je gebruikt.

en: It is recommended to use the binary installer provided from upstream. Should you insist on using a package provided by your distribution, use the ``CALIBRE_PYTHON_PATH`` and ``CALIBRE_RESOURCES_PATH`` variables instead. You can get these by running ``calibre-debug --paths``. But note that distribution calibre packages are often terminally broken and are completely unsupported.
nl: Het wordt aanbevolen om het binaire installatieprogramma te gebruiken dat vanaf upstream wordt geleverd. Als u erop staat een pakket te gebruiken dat door uw distributie wordt geleverd, gebruik dan in plaats daarvan de variabelen ''CALIBRE_PYTHON_PATH'' en ''CALIBRE_RESOURCES_PATH'. Je kunt deze krijgen door  ``calibre-debug --paths`` uit te voeren. Maar houd er rekening mee dat distributiepakketten van calibre vaak terminaal kapot zijn en totaal niet worden ondersteund.

en: Once you have set the environment variable, open a new terminal and check that it was correctly set by using the command::
nl: Nadat u de omgevingsvariabele hebt ingesteld, opent u een nieuwe terminal en controleert u of deze correct is ingesteld met de opdracht::

en: That's it! You are now ready to start hacking on the calibre code. For example, open the file :file:`src/calibre/__init__.py` in your favorite editor and add the line::
nl: Das alles! U bent nu klaar om de calibre code te beginnen hacken. Bv. open het bestand :file:`src\\calibre\\__init__.py` in uw favoriete editor en voeg volgende regel toe::

en: Having separate "normal" and "development" calibre installs on the same computer
nl: Afzonderlijke "normale" en "ontwikkel" calibre installaties op dezelfde computer hebben

en: The calibre source tree is very stable and rarely breaks, but if you feel the need to run from source on a separate test library and run the released calibre version with your everyday library, you can achieve this easily using .bat files or shell scripts to launch calibre. The example below shows how to do this on Windows using .bat files (the instructions for other platforms are the same, just use a shell script instead of a .bat file)
nl: De calibre bronboom is heel stabiel en breekt zelden maar als u de behoefte voelt om vanuit de bron te draaien op een aparte testbibliotheek en de uitgegeven calibre versie met uw dagdagelijkse bibliotheek, kan u dat gemakkelijk met .bat bestanden of shellscripts om calibre te starten. Het voorbeeld onder toont hoe dit te doen in Windows met .bat bestanden (de instructies voor andere platformen zijn hetzelfde, gebruik gewoon een shellscript i.p.v. een .bat bestand).

en: To launch the release version of calibre with your everyday library:
nl: De releaseversie van calibre lanceren met uw alledaagse bibliotheek

en: calibre-normal.bat::
nl: Calibre-normal.bat::

en: calibre-dev.bat::
nl: Calibre-dev.bat::

en: Debugging tips
nl: Debug tips

en: Python is a dynamically typed language with excellent facilities for introspection. Kovid wrote the core calibre code without once using a debugger. There are many strategies to debug calibre code:
nl: Python is een dynamisch getypeerde taal met uitstekend onderdak voor introspectie. Kovid schreef de kern calibre code zonder ook maar één keer een foutzoeker te gebruiken. Er zijn veel strategieën voor foutzoeken in calibre code:

en: Using print statements
nl: Gebruik van print statements

en: This is Kovid's favorite way to debug. Simply insert print statements at points of interest and run your program in the terminal. For example, you can start the GUI from the terminal as::
nl: Dit is de favoriete manier van Kovid om te debuggen. Voeg eenvoudig afdrukinstructies in op interessante plaatsen en voer uw programma uit in de terminal. U kunt de GUI bijvoorbeeld vanuit de terminal starten als::

en: Similarly, you can start the E-book viewer as::
nl: U kan de e-boekviewer ook starten als::

en: The e-book editor can be started as::
nl: De e-boekbewerker kan worden gestart als:

en: Using an interactive Python interpreter
nl: Een interactieve Python vertaler gebruiken

en: You can insert the following two lines of code to start an interactive Python session at that point::
nl: U kan de volgende twee regels code invoegen om op dat punt een interactieve Python sessie te starten::

en: When running from the command line, this will start an interactive Python interpreter with access to all locally defined variables (variables in the local scope). The interactive prompt even has :kbd:`Tab` completion for object properties and you can use the various Python facilities for introspection, such as :func:`dir`, :func:`type`, :func:`repr`, etc.
nl: Bij het uitvoeren van de opdrachtregel start hiermee een interactieve Python vertaler met toegang tot alle lokaal gedefinieerde variabelen (variabelen in de lokale scope). De interactieve prompt heeft zelfs :kbd:`Tab` voltooiing voor objecteigenschappen en u kunt de verschillende Python faciliteiten gebruiken voor introspectie, zoals :func:`dir`, :func:`type`, :func:`repr`, enz.

en: Using the Python debugger as a remote debugger
nl: De Python foutzoeker als een externe foutzoeker gebruiken

en: You can use the builtin Python debugger (pdb) as a remote debugger from the command line. First, start the remote debugger at the point in the calibre code you are interested in, like this::
nl: U kan de ingebouwde Python foutzoeker gebruiken (pdb) als een externe foutzoeker vanop de opdrachtregel. Om te beginnen, start de externe foutzoeker op de plaats in de code waar u in geïnteresseerd bent, zoals dit::

en: Then run calibre, either as normal, or using one of the calibre-debug commands described in the previous section. Once the above point in the code is reached, calibre will freeze, waiting for the debugger to connect.
nl: Voer vervolgens Calibre uit, hetzij als normaal, of met behulp van een van de Calibre-debug-opdrachten die in de vorige sectie zijn beschreven. Zodra het bovenstaande punt in de code is bereikt, zal Calibre bevriezen, wachtend totdat de foutopsporing verbinding maakt.

en: Now open a terminal or command prompt and use the following command to start the debugging session::
nl: Open nu een terminal of opdrachtprompt en gebruik de volgende opdracht om de foutopsporingssessie te starten:

en: You can read about how to use the Python debugger in the `Python stdlib docs for the pdb module <https://docs.python.org/library/pdb.html#debugger-commands>`_.
nl: U kan lezen hoe de Python foutzoeker te gebruiken in de `Python stdlib docs voor de pdb module <https://docs.python.org/library/pdb.html#debugger-commands>`_.

en: By default, the remote debugger will try to connect on port 4444. You can change it, by passing the port parameter to both the set_trace() and the cli() functions above, like this: ``set_trace(port=1234)`` and ``cli(port=1234)``.
nl: Standaard probeert de debugger op afstand verbinding te maken op poort 4444. Je kunt dit wijzigen door de parameter port naar zowel de set_trace() als de cli() -functies hierboven door te geven, zoals deze: ``set_trace(port=1234)``en``cli(port = 1234)``.

en: The Python debugger cannot handle multiple threads, so you have to call set_trace once per thread, each time with a different port number.
nl: De Python foutzoeker kan niet met meerdere draadjes overweg, u moet set_trace dus voor elk draadje roepen, elke keer met een ander poortnummer.

en: Using the debugger in your favorite Python IDE
nl: De foutzoeker gebruiken in uw favoriete Python IDE

en: It is possible to use the builtin debugger in your favorite Python IDE, if it supports remote debugging. The first step is to add the calibre src checkout to the ``PYTHONPATH`` in your IDE. In other words, the folder you set as ``CALIBRE_DEVELOP_FROM`` above, must also be in the ``PYTHONPATH`` of your IDE.
nl: Het is mogelijk om de ingebouwde foutzoeker van uw favoriete Python IDE te gebruiken, als hij extern foutzoeken ondersteunt. De eerste stap is toevoegen van de calibre scr checkout aan ``PYTHONPATH`` in uw IDE. M.a.w. de map die u instelde als ``CALIBRE_DEVELOP_FROM`` boven moet ook in  ``PYTHONPATH`` van uw IDE staan.

en: Then place the IDE's remote debugger module into the :file:`src` sub-folder of the calibre source code checkout. Add whatever code is needed to launch the remote debugger to calibre at the point of interest, for example in the main function. Then run calibre as normal. Your IDE should now be able to connect to the remote debugger running inside calibre.
nl: Plaats dan de IDE's externe foutzoekmodule in de :file:`src` submap van de calibre broncode checkout. Voeg de nodige code toe om de externe foutzoeker te starten op het punt van interesse, bv. in de hoofdfunctie. Draai calibre dan als gewoonlijk. Uw IDE  zou nu moeten kunnen verbinden met de externe foutzoeker die in calibre draait.

en: Executing arbitrary scripts in the calibre Python environment
nl: Willekeurige scripts uitvoeren in de calibre Python omgeving

en: The :command:`calibre-debug` command provides a couple of handy switches to execute your own code, with access to the calibre modules::
nl: Het :command:`calibre-debug` commando voorziet enkele handige schakelaars om uw eigen code uit te voeren, met toegang tot de calibre modules::

en: is great for testing a little snippet of code on the command line. It works in the same way as the -c switch to the Python interpreter::
nl: is geweldig om een klein code knipseltje te testen op de commandoregel. Werkt op dezelfde manier als de -c schakelaar naar de Python vertaler::

en: can be used to execute your own Python script. It works in the same way as passing the script to the Python interpreter, except that the calibre environment is fully initialized, so you can use all the calibre code in your script. To use command line arguments with your script, use the form::
nl: kan worden gebruikt om je eigen Python-script uit te voeren. Het werkt op dezelfde manier als het doorgeven van het script aan de Python-interpreter, behalve dat de Calibre omgeving volledig is geïnitialiseerd, zodat u alle Calibre code in uw script kunt gebruiken. om opdrachtregelargumenten te gebruiken met uw script, gebruik de vorm:

en: The ``--`` causes all subsequent arguments to be passed to your script.
nl: De `` --`` zorgt ervoor dat alle volgende argumenten aan je script worden doorgegeven.

en: Using calibre in your projects
nl: Calibre gebruiken in uw projecten

en: It is possible to directly use calibre functions/code in your Python project. Two ways exist to do this:
nl: Het is mogelijk calibre functies/code direct te gebruiken  in uw Python project. Er zijn twee manieren om dit te doen:

en: Binary install of calibre
nl: Binaire installatie van Calibre

en: If you have a binary install of calibre, you can use the Python interpreter bundled with calibre, like this::
nl: Als u een binaire installatie van calibre hebt, kan u de Python vertaler, gebundeld met calibre, zo gebruiken::

en: Source install on Linux
nl: Broncode installatie op Linux

en: In addition to using the above technique, if you do a source install on Linux, you can also directly import calibre, as follows::
nl: Bijkomend aan de techniek boven, als u een broninstallatie doet in Linux kan u calibre ook direct importeren, op deze manier::

en: It is essential that you import the init_calibre module before any other calibre modules/packages as it sets up the interpreter to run calibre code.
nl: Het is essentieel dat u de init_calibre module importeert voor enige andere calibre modules/packages want het stelt de vertaler in om de calibre code te draaien.

en: API documentation for various parts of calibre
nl: API installatie voor diverse onderdelen van Calibre
