calibre - en to sv translation catalogue (104 entries)

en: Setting up a calibre development environment
sv: Konfigurera en utvecklingsmiljö för calibre

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.
sv: calibre har helt öppen källkod och är licensierat under `GNU GPL v3 <https://www.gnu.org/licenses/gpl.html>`_. Det innebär att du fritt kan hämta och ändra programmet så mycket du vill. I det här avsnittet får du lära dig hur du konfigurerar en utvecklingsmiljö för calibre på valfritt operativsystem. calibre är huvudsakligen skrivet i `Python <https://www.python.org>`_, med viss C/C++-kod för bättre prestanda och systemintegration. Observera att calibre kräver minst Python 3.8.

en: Contents
sv: Innehåll

en: Design philosophy
sv: Designfilosofi

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`.
sv: calibre har sina rötter i Unix-världen, vilket innebär att dess design är mycket modulär. Modulerna samverkar via väldefinierade gränssnitt. Det gör det mycket enkelt att lägga till nya funktioner och rätta fel i calibre, vilket ger en snabb utvecklingstakt. Tack vare sina rötter har calibre ett omfattande kommandoradsgränssnitt för samtliga funktioner, dokumenterat i :doc:`generated/sv/cli-index`.

en: The modular design of calibre is expressed via ``Plugins``. There is a :ref:`tutorial <customize>` on writing calibre plugins. For example, adding support for a new device to calibre typically involves writing fewer than 100 lines of code in the form of a device driver plugin. You can browse the `built-in drivers <https://github.com/kovidgoyal/calibre/tree/master/src/calibre/devices>`_. Similarly, adding support for new conversion formats involves writing input/output format plugins. Another example of the modular design is the :ref:`recipe system <news>` for fetching news. For more examples of plugins designed to add features to calibre, see the `Index of plugins <https://www.mobileread.com/forums/showthread.php?p=1362767#post1362767>`_.
sv: calibres modulära design bygger på ``insticksmoduler``. Det finns en :ref:`handledning <customize>` om hur du skriver insticksmoduler för calibre. Att lägga till stöd för en ny enhet kräver till exempel vanligtvis färre än 100 rader kod i form av en insticksmodul för enhetsdrivrutinen. Du kan bläddra bland de `inbyggda drivrutinerna <https://github.com/kovidgoyal/calibre/tree/master/src/calibre/devices>`_. På motsvarande sätt lägger du till stöd för nya konverteringsformat genom att skriva insticksmoduler för in- och utmatningsformat. Ett annat exempel på den modulära designen är :ref:`receptsystemet <news>` för att hämta nyheter. Fler exempel på insticksmoduler som lägger till funktioner i calibre finns i `indexet över insticksmoduler <https://www.mobileread.com/forums/showthread.php?p=1362767#post1362767>`_.

en: Code layout
sv: Kodstruktur

en: All the calibre Python code is in the ``calibre`` package. This package contains the following main sub-packages
sv: All Python-kod i calibre finns i paketet ``calibre``. Paketet innehåller följande huvudsakliga underpaket

en: devices - All the device drivers. Just look through some of the built-in drivers to get an idea for how they work.
sv: devices – Alla enhetsdrivrutiner. Titta igenom några av de inbyggda drivrutinerna för att få en uppfattning om hur de fungerar.

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.
sv: Mer information finns i ``devices.interface``, som definierar gränssnittet som enhetsdrivrutiner stöder, och ``devices.usbms``, som definierar en allmän drivrutin för anslutning till en USBMS-enhet. Alla USBMS-baserade drivrutiner i calibre ärver från den.

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``.
sv: e-books – All kod för e-bokskonvertering och metadata. En bra utgångspunkt är ``calibre.ebooks.conversion.cli``, modulen som driver kommandot :command:`ebook-convert`. Konverteringsprocessen styrs via ``conversion.plumber``. All formatoberoende kod finns i ``ebooks.oeb`` och den formatberoende koden i ``ebooks.format_name``.

en: Metadata reading, writing, and downloading is all in ``ebooks.metadata``
sv: All läsning, skrivning och hämtning av metadata finns i ``ebooks.metadata``

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`.
sv: Konverteringen sker i en bearbetningskedja. Information om kedjans struktur finns i :ref:`conversion-introduction`. Kedjan består av en insticksmodul för inmatning, olika omvandlingar och en insticksmodul för utmatning. Koden som bygger upp och driver kedjan finns i :file:`plumber.py`. Kedjan arbetar med en representation av en e-bok som liknar en uppackad EPUB, med manifest, läsordning, innehållsförteckning, guide, HTML-innehåll och så vidare. Klassen som hanterar representationen är OEBBook i ``ebooks.oeb.base``. De olika omvandlingarna som tillämpas på boken under konverteringen finns i :file:`oeb/transforms/*.py`. Insticksmodulerna för in- och utmatning finns i :file:`conversion/plugins/*.py`.

en: E-book editing happens using a different container object. It is documented in :ref:`polish_api`.
sv: E-boksredigering använder ett annat behållarobjekt. Det dokumenteras i :ref:`polish_api`.

en: db - The database back-end. See :ref:`db_api` for the interface to the calibre library.
sv: db - Databasens backend. Se :ref:`db_api` för gränssnittet till calibre-biblioteket.

en: Content server: ``srv`` is the calibre Content server.
sv: Innehållsserver: ``srv`` är calibre-innehållsservern.

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``.
sv: gui2 – Det grafiska användargränssnittet. Gränssnittet initieras i ``gui2.main`` och ``gui2.ui``. E-bokvisaren finns i ``gui2.viewer``. E-bokredigeraren finns i ``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>`_.
sv: Om du vill hitta startpunkterna för de olika körbara calibre-programmen, titta på strukturen ``entry_points`` i `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.
sv: Om du behöver hjälp med att förstå koden kan du göra ett inlägg i `utvecklingsforumet <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_. Du får sannolikt hjälp av någon av calibres många utvecklare.

en: Getting the code
sv: Hämta koden

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>`.
sv: Du kan hämta calibres källkod på två sätt: med ett versionshanteringssystem eller genom att hämta ett :website_base:`tar-arkiv <dist/src>` direkt.

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::
sv: calibre använder `Git <https://www.git-scm.com/>`_, ett distribuerat versionshanteringssystem. Git är tillgänglig på alla plattformar som calibre stöder. När du har installerat Git kan du få calibre-källkoden med kommandot::

en: On Windows you will need the complete path name, that will be something like :file:`C:\\Program Files\\Git\\git.exe`.
sv: I Windows behöver du det fullständiga sökvägsnamnet som kommer att vara något i stil med :file:`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).
sv: calibre är ett mycket stort projekt med en mycket lång versionshanteringshistorik, så kommandot ovan kan ta en stund, från 10 minuter till en timme beroende på din internethastighet.

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>`.
sv: Om du vill hämta koden snabbare är källkoden för den senaste utgåvan alltid tillgänglig som ett :website_base:`arkiv <dist/src>`.

en: To update a branch to the latest code, use the command::
sv: Använd följande kommando för att uppdatera en gren till den senaste koden::

en: You can also browse the code at `GitHub <https://github.com/kovidgoyal/calibre>`_.
sv: Du kan också se koden på `GitHub <https://github.com/kovidgoyal/calibre>`_.

en: Submitting your changes to be included
sv: Skicka in ändringar för införande

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::
sv: Om du bara planerar att göra några mindre ändringar kan du genomföra dem och skapa ett ”merge directive” som du sedan bifogar till ett ärende i calibres `felrapporteringssystem <https://bugs.launchpad.net/calibre>`_. Gör ändringarna och kör sedan::

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::
sv: Det skapar filen :file:`my-changes` i den aktuella mappen. Bifoga den till ett ärende i calibres `felrapporteringssystem <https://bugs.launchpad.net/calibre>`_. Observera att filen innehåller *alla* incheckningar du har gjort. Om du bara vill skicka vissa incheckningar måste du ändra ``origin/master`` ovan. Använd följande för att endast skicka den senaste incheckningen::

en: To send the last *n* commits, replace *1* with *n*, for example, for the last 3 commits::
sv: Om du vill skicka de senaste *n* incheckningarna ersätter du *1* med *n*. För de senaste tre incheckningarna använder du till exempel::

en: Be careful to not include merges when using ``HEAD~n``.
sv: Var noga med att inte inkludera sammanslagningar när du använder ``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:
sv: Om du planerar att utveckla mycket för calibre är den bästa metoden att skapa ett konto på `GitHub <https://github.com>`__. Nedan följer en grundläggande guide för hur du skapar en egen förgrening av calibre så att du kan skicka pull-begäranden för införande i calibres huvudförråd:

en: Setup git on your machine as described in this article: `Setup Git <https://help.github.com/articles/set-up-git>`_
sv: Konfigurera Git på datorn enligt artikeln `Konfigurera 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>`_
sv: Konfigurera SSH-nycklar för autentisering mot GitHub enligt anvisningarna här: `Skapa SSH-nycklar <https://help.github.com/articles/generating-ssh-keys>`_

en: Go to https://github.com/kovidgoyal/calibre and click the :guilabel:`Fork` button.
sv: Gå till https://github.com/kovidgoyal/calibre och klicka på knappen :guilabel:`Fork`.

en: In a Terminal do::
sv: Kör följande i en terminal::

en: Replace <username> above with your GitHub username. That will get your fork checked out locally.
sv: Ersätt <username> ovan med ditt användarnamn på GitHub. Din förgrening checkas då ut lokalt.

en: You can make changes and commit them whenever you like. When you are ready to have your work merged, do a::
sv: Du kan göra ändringar och checka in dem när du vill. När du är redo att få arbetet sammanslaget kör du::

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.
sv: Gå sedan till ``https://github.com/<username>/calibre`` och klicka på knappen :guilabel:`Pull Request` för att skapa en pull-begäran som kan slås samman.

en: You can update your local copy with code from the main repo at any time by doing::
sv: Du kan när som helst uppdatera din lokala kopia med kod från huvudförrådet genom att köra::

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).
sv: Du bör också hålla ett öga på calibres `utvecklingsforum <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_. Innan du gör större ändringar bör du diskutera dem i forumet eller kontakta Kovid direkt. Hans e-postadress finns på många ställen i källkoden.

en: Windows development environment
sv: Windows-utvecklingsmiljö

en: You must also get the calibre source code separately as described above.
sv: Du måste också hämta calibre-källkoden separat enligt beskrivningen ovan.

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::
sv: Installera calibre på vanligt sätt med `installationsprogrammet för Windows <https://calibre-ebook.com/download_windows>`__. Öppna sedan en kommandotolk och växla till den tidigare utcheckade mappen med calibre-koden. Till exempel::

en: calibre is the folder that contains the src and resources sub-folders.
sv: calibre är mappen som innehåller undermapparna src och resources.

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.
sv: Nästa steg är att ställa in miljövariabeln ``CALIBRE_DEVELOP_FROM`` på den absoluta sökvägen till mappen src. I exemplet ovan blir det ``C:\Users\kovid\work\calibre\src``. `Här finns en kort guide <https://docs.python.org/using/windows.html#excursus-setting-environment-variables>`_ till hur du ställer in miljövariabler i 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::
sv: När du har ställt in miljövariabeln öppnar du en ny kommandotolk och kontrollerar med följande kommando att den är korrekt inställd::

en: Setting this environment variable means that calibre will now load all its Python code from the specified location.
sv: När den här miljövariabeln ställs in läser calibre in all sin Python-kod från den angivna platsen.

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::
sv: Klart! Nu kan du börja arbeta med calibre-koden. Öppna till exempel filen :file:`src\\calibre\\__init__.py` i din favoritredigerare och lägg till raden::

en: near the top of the file. Now run the command :command:`calibredb`. The very first line of output should be ``Hello, world!``.
sv: nära början av filen. Kör sedan kommandot :command:`calibredb`. Den första utdataraden ska vara ``Hello, world!``.

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>`_.
sv: Du kan också konfigurera en utvecklingsmiljö för calibre i kostnadsfria Microsoft Visual Studio genom att följa anvisningarna `här <https://www.mobileread.com/forums/showthread.php?t=251201>`_.

en: macOS development environment
sv: macOS-utvecklingsmiljö

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::
sv: Installera calibre på vanligt sätt med den `medföljande DMG-filen <https://calibre-ebook.com/download_osx>`__. Öppna sedan Terminal och växla till den tidigare utcheckade mappen med calibre-koden, till exempel::

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.
sv: calibre är mappen som innehåller undermapparna src och resources. Calibres kommandoradsverktyg finns i calibre-appens paket, i :file:`/Applications/calibre.app/Contents/MacOS`. Lägg till den mappen i miljövariabeln PATH om du enkelt vill kunna köra kommandoradsverktygen.

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.
sv: Nästa steg är att skapa ett bash-skript som ställer in miljövariabeln ``CALIBRE_DEVELOP_FROM`` på den absoluta sökvägen till mappen src när calibre körs i felsökningsläge.

en: Create a plain text file::
sv: Skapa en vanlig textfil::

en: Save this file as :file:`/usr/local/bin/calibre-develop`, then set its permissions so that it can be executed::
sv: Spara den här filen som :file:`/usr/local/bin/calibre-develop` och ställ sedan in dess behörigheter så att den kan köras::

en: Once you have done this, run::
sv: När du har gjort detta, kör::

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.
sv: När calibre startar bör du se diagnostisk information i terminalfönstret och en asterisk efter versionsnumret i GUI-fönstret. Asterisken visar att du kör från källkoden.

en: Linux development environment
sv: Linux-utvecklingsmiljö

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.
sv: calibre utvecklas främst på Linux. Du kan konfigurera utvecklingsmiljön på två sätt. Antingen installerar du calibres binärversion på vanligt sätt och använder den som körmiljö för utvecklingen, på samma sätt som i Windows och macOS, eller så installerar du calibre från källkoden. Anvisningar för att konfigurera en utvecklingsmiljö från källkoden finns i filen INSTALL i källkodsträdet. Här beskriver vi hur binärversionen används som körmiljö, vilket är den rekommenderade metoden.

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::
sv: Installera calibre med hjälp av `det binära installationsprogrammet <https://calibre-ebook.com/download_linux>`_. Öppna sedan en terminal och ändra till den tidigare kontrollerade calibre-kodmappen, till exempel::

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.
sv: Nästa steg är att ställa in miljövariabeln ``CALIBRE_DEVELOP_FROM`` till den absoluta sökvägen till mappen src. Så, efter exemplet ovan, skulle det vara ``/home/kovid/work/calibre/src``. Hur man ställer in miljövariabler beror på din Linux-distribution och vilket skal du använder.

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.
sv: Vi rekommenderar att du använder det binära installationsprogrammet från huvudprojektet. Om du ändå vill använda ett paket från din distribution ska du i stället använda variablerna ``CALIBRE_PYTHON_PATH`` och ``CALIBRE_RESOURCES_PATH``. Du kan få fram dem genom att köra ``calibre-debug --paths``. Observera dock att distributionernas calibre-paket ofta är allvarligt trasiga och inte stöds alls.

en: Once you have set the environment variable, open a new terminal and check that it was correctly set by using the command::
sv: När du har ställt in miljövariabeln, öppna en ny terminal och kontrollera att den blev korrekt inställd genom att använda kommandot::

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::
sv: Klart! Nu kan du börja arbeta med calibre-koden. Öppna till exempel filen :file:`src/calibre/__init__.py` i din favoritredigerare och lägg till raden::

en: Having separate "normal" and "development" calibre installs on the same computer
sv: Ha separata installationer av den vanliga versionen och utvecklingsversionen av calibre på samma dator

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)
sv: Calibres källkodsträd är mycket stabilt och slutar sällan fungera. Om du ändå vill köra källkodsversionen med ett separat testbibliotek och den utgivna calibre-versionen med ditt vanliga bibliotek kan du enkelt göra det genom att starta calibre med .bat-filer eller skalskript. Exemplet nedan visar hur du gör i Windows med .bat-filer. På andra plattformar är anvisningarna desamma, men du använder ett skalskript i stället för en .bat-fil.

en: To launch the release version of calibre with your everyday library:
sv: Så här startar du den utgivna versionen av calibre med ditt vanliga bibliotek:

en: Debugging tips
sv: Felsökningstips

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:
sv: Python är ett dynamiskt typat språk med utmärkta möjligheter till introspektion. Kovid skrev kärnan i calibre utan att någonsin använda en felsökare. Det finns många sätt att felsöka calibre-kod:

en: Using print statements
sv: Använda utskriftssatser

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::
sv: Det här är Kovids favoritsätt att felsöka. Infoga helt enkelt utskriftssatser på intressanta ställen och kör programmet i terminalen. Du kan till exempel starta GUI:t från terminalen med::

en: Similarly, you can start the E-book viewer as::
sv: På samma sätt kan du starta e-bokvisaren med::

en: The e-book editor can be started as::
sv: E-bokredigeraren kan startas som::

en: Using an interactive Python interpreter
sv: Använda en interaktiv Python-tolk

en: You can insert the following two lines of code to start an interactive Python session at that point::
sv: Du kan infoga följande två kodrader för att starta en interaktiv Python-session vid den aktuella punkten::

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.
sv: När du kör från kommandoraden startar detta en interaktiv Python-tolk med åtkomst till alla lokalt definierade variabler, det vill säga variabler i det lokala omfånget. Den interaktiva prompten har till och med :kbd:`Tab`-komplettering för objektegenskaper, och du kan använda Pythons olika funktioner för introspektion, till exempel :func:`dir`, :func:`type` och :func:`repr`.

en: Using the Python debugger as a remote debugger
sv: Använda Python-felsökaren som fjärrfelsökare

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::
sv: Du kan använda den inbyggda Python-felsökaren (pdb) som en fjärrfelsökare från kommandoraden. Starta först fjärrfelsökaren vid den punkt i calibre-koden du är intresserad av, så här::

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.
sv: Kör sedan calibre på vanligt sätt eller med något av kommandona för calibre-debug som beskrivs i föregående avsnitt. När den aktuella punkten i koden nås fryser calibre och väntar på att felsökaren ska ansluta.

en: Now open a terminal or command prompt and use the following command to start the debugging session::
sv: Öppna nu en terminal eller kommandotolk och använd följande kommando för att starta felsökningssessionen::

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>`_.
sv: Du kan läsa om hur Python-felsökaren används i `Pythons standardbiblioteksdokumentation för pdb-modulen <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)``.
sv: Som standard försöker fjärrfelsökaren ansluta via port 4444. Du kan ändra porten genom att skicka portparametern till både funktionerna set_trace() och cli() ovan, så här: ``set_trace(port=1234)`` och ``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.
sv: Python-felsökaren kan inte hantera flera trådar, så du måste anropa set_trace en gång per tråd, varje gång med ett annat portnummer.

en: Using the debugger in your favorite Python IDE
sv: Använda felsökaren i din favorit-IDE för Python

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.
sv: Du kan använda den inbyggda felsökaren i din favorit-IDE för Python om den stöder fjärrfelsökning. Lägg först till den utcheckade src-mappen för calibre i ``PYTHONPATH`` i din IDE. Med andra ord måste mappen som du angav som ``CALIBRE_DEVELOP_FROM`` ovan även finnas i IDE:ns ``PYTHONPATH``.

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.
sv: Placera sedan IDE:ns fjärrfelsökningsmodul i undermappen :file:`src` i den utcheckade calibre-källkoden. Lägg till den kod som krävs för att starta fjärrfelsökaren i calibre vid den punkt du vill undersöka, till exempel i huvudfunktionen. Kör därefter calibre som vanligt. Din IDE bör nu kunna ansluta till fjärrfelsökaren som körs inuti calibre.

en: Executing arbitrary scripts in the calibre Python environment
sv: Köra godtyckliga skript i Python-miljön för calibre

en: The :command:`calibre-debug` command provides a couple of handy switches to execute your own code, with access to the calibre modules::
sv: Kommandot :command:`calibre-debug` har ett par praktiska växlar för att köra egen kod med åtkomst till calibre-modulerna::

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::
sv: är utmärkt för att testa ett kort kodavsnitt på kommandoraden. Det fungerar på samma sätt som växeln -c för Python-tolken::

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::
sv: kan användas för att köra ett eget Python-skript. Det fungerar på samma sätt som att skicka skriptet till Python-tolken, förutom att calibre-miljön är fullständigt initierad så att du kan använda all calibre-kod i skriptet. Om du vill använda kommandoradsargument med skriptet använder du följande form::

en: The ``--`` causes all subsequent arguments to be passed to your script.
sv: ``--`` gör att alla efterföljande argument skickas till ditt skript.

en: Running the calibre test suite
sv: Köra calibres testsvit

en: The calibre test suite can be run by::
sv: Calibres testsvit kan köras med::

en: Using calibre in your projects
sv: Använda calibre i dina projekt

en: It is possible to directly use calibre functions/code in your Python project. Two ways exist to do this:
sv: Det är möjligt att direkt använda calibre-funktioner/-kod i ditt Python-projekt. Det finns två sätt att göra detta:

en: Binary install of calibre
sv: Binär installation av calibre

en: If you have a binary install of calibre, you can use the Python interpreter bundled with calibre, like this::
sv: Om du har en binär installation av calibre kan du använda Python-tolken som medföljer calibre, så här::

en: Source install on Linux
sv: Källkodsinstallation på 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::
sv: Förutom att använda metoden ovan kan du, om du installerar från källkod på Linux, även importera calibre direkt enligt följande::

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.
sv: Det är viktigt att du importerar modulen init_calibre före andra calibre-moduler/-paket eftersom den ställer in tolken för att köra calibre-kod.

en: API documentation for various parts of calibre
sv: API-dokumentation för olika delar av calibre
