calibre - en to sv translation catalogue (102 entries)

en: Setting up a calibre development environment
sv: Inrätta en calibre-utvecklingsmiljö

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, licensierad under `GNU GPL v3 <https://www.gnu.org/licenses/gpl.html>`_. Detta innebär att du är fri att hämtar och ändra programmet hur mycket du vill. I det här avsnittet får du lära dig hur du inrättar en calibre-utvecklingsmiljö på valfritt operativsystem. calibre är främst skriven i `Python <https://www.python.org>`_ med lite C/C++-kod för hastighet och systemgränssnitt. Observera att calibre kräver minst Python 3.8.

en: Contents
sv: Innehåll

en: Design philosophy
sv: Konstruktionsfilosofi

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 med varandra via väl definierade gränssnitt. Detta gör det mycket lätt att lägga till nya funktioner och rätta problem i calibre, vilket resulterar i en frenetisk utvecklingstakt. På grund av sina rötter har calibre ett omfattande kommandoradsgränssnitt för alla dess 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: Den modulära designen av calibre uttrycks via "insticksmoduler". Det finns en :ref:`tutorial <customize>` om hur man skriver insticksmoduler för calibre. Till exempel innebär det att lägga till stöd för en ny enhet till calibre vanligtvis att man skriver färre än 100 rader kod i form av ett enhetsdrivrutinsinsticksmodul. Du kan bläddra bland de "inbyggda drivrutinerna <https://github.com/kovidgoyal/calibre/tree/master/src/calibre/devices>`_. På liknande sätt innebär det att lägga till stöd för nya konverteringsformat att man skriver in-/utdataformatsinsticksmoduler. Ett annat exempel på den modulära designen är :ref:`recipe system <news>` för att hämta nyheter. För fler exempel på insticksmoduler utformade för att lägga till funktioner till calibre, se "Index över insticksmoduler <https://www.mobileread.com/forums/showthread.php?p=1362767#post1362767>`_.

en: Code layout
sv: Kodutformning

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

en: devices - All the device drivers. Just look through some of the built-in drivers to get an idea for how they work.
sv: enheter - Alla enhetsdrivrutiner. Titta bara 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: För mer information, se: ``devices.interface`` som definierar gränssnitt stöds av drivrutiner och ``devices.usbms`` som definierar en generisk drivrutin som ansluter 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-böcker - All e-bokkonvertering/metadatakod. En bra utgångspunkt är ``calibre.ebooks.conversion.cli`` vilken är modulen som driver :command:`ebook-convert` kommandot. Konverteringen styrs via ``conversion.plumber``. Formatoberoende kod är alla i ``ebooks.oeb`` och formatberoende kod finns i ``ebooks.format_name``.

en: Metadata reading, writing, and downloading is all in ``ebooks.metadata``
sv: Metadataläsning, skrivning, och hämtning 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: Konvertering sker i en process, för strukturen av processen, se :ref:`conversion-introduction`. Processen består av en inmatningsinsticksmodul, olika omvandlingar och en utmatningsinsticksmodul. Koden som konstruerar och driver processen i :file:`plumber.py`. Processen fungerar på en representation av en e-bok som är som en uppackad EPUB, med manifest, bokrygg, innehållsförteckning, guide, html-innehåll, etc. Klassen som hanterar den här representationen är OEBBook i ``ebooks.oeb.base`` . De olika omvandlingarna som tillämpas på boken under konvertering finns i :file:`oeb/transforms/*.py`. Och in- och utmatningsinsticksmodulerna 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-bokredigering sker med hjälp av en annat kontainerobjekt. Det är dokumenterat 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 - Grafiska användargränssnittet. Grafiska gränssnittet initialiseringen händer 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 startplatser för alla olika calibre körbara delar, titta på ``entry_points``-strukturen 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, skicka inlägg i det så kallade utvecklingsforumet <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_ och du kommer sannolikt att få hjälp från en av calibres många utvecklare .

en: Getting the code
sv: Få 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 calibre-källkoden på två sätt, med hjälp av ett versionshanteringssystem eller direkt hämta en :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::
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 källkontrollshistorik, så ovanstående kan ta ett tag (10 minuter till en timme beroende på din internet hastighet).

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: För att uppdatera en filial till den senaste koden använder du kommandot::

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 dina ändringar som ska ingå

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 små ändringar kan du göra dina ändringar och skapa ett "sammanslagningsdirektiv" som du sedan kan fästa till ett ärende i calibre-`felhanteringssystemet <https://bugs.launchpad.net/calibre>`_.  För att göra detta, gör dina ändringar, 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: Detta kommer att skapa en :file:`my-changes`-fil i den aktuella mappen, helt enkelt bifoga det till ett ärende i calibre-`felhanteringssystemet <https://bugs.launchpad.net/calibre>`_. Observera att detta kommer att omfatta *alla* de åtgärder du har gjort. Om du bara vill skicka några åtgärder måste du ändra ``origin/master`` ovan. Om du vill skicka bara den senaste bekräftelsen, använd::

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* ändringar, ersätt *1* med *n* , till exempel under de senaste 3 ändringarna::

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 göra en hel del utveckling på calibre, är den bästa metoden att skapa ett `GitHub <https://github.com>`__-konto. Nedan följer en grundläggande guide för att ställa in din egen förgrening av calibre på ett sätt som gör att du kan skicka förfrågningar för inkludering i calibre-huvudförrådet:

en: Setup git on your machine as described in this article: `Setup Git <https://help.github.com/articles/set-up-git>`_
sv: Installering av git på din maskin som beskrivs i denna 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>`_
sv: Ställ in ssh-nycklar för autentisering till GitHub, som beskrivs här: `Generating SSH keys <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: I en terminal utför::

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. Det kommer att få din förgrening kontrollerad 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 skicka in dem när du vill. När du är redo att slå samman ditt arbete, gör en::

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: och gå till ``https://github.com/<username>/calibre`` och klicka på knappen :guilabel:`Pull Request` för att skapa en hämtningsbegä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 huvudarkivet genom att gö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å calibre-`utvecklingsforumet <https://www.mobileread.com/forums/forumdisplay.php?f=240>`_. Innan du gör stora ändringar bör du diskutera dem i forumet eller kontakta Kovid direkt (hans e-postadress är över hela 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 normalt med hjälp av `installationsprogrammet för Windows <https://calibre-ebook.com/download_windows>`__. Öppna sedan en kommandotolk och ändra till den tidigare kontrollerade calibre-kodmappen. Till exempel::

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

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`` till den absoluta sökvägen för mappen src. Så efter exemplet ovan skulle det vara ``C:\Users\kovid\work\calibre\src``. `Här är en kort guide <https://docs.python.org/using/windows.html#excursus-setting-environment-variables>`_  för att ställa 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, öppna en ny kommandotolk och kontrollera att den blev korrekt inställd genom att använda kommandot::

en: Setting this environment variable means that calibre will now load all its Python code from the specified location.
sv: Ställa denna miljövariabel innebär att calibre kommer nu läsa 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: Det är allt! Du är nu redo att börja hacka calibre-koden. Till exempel öppna filen :file:`src\\calibre\\__init__.py` i din favorit redigerare 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 toppen av filen. Kör nu kommandot :command:`calibredb` . Den allra första raden av utmatningen bör vara ``Hej världen!``.

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å ställa in en calibre-utvecklingsmiljö i gratis Microsoft Visual Studio, om du vill, genom att följa instruktionerna `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 normalt med hjälp av `den tillhandahållna .dmg <https://calibre-ebook.com/download_osx>`__. Öppna sedan en terminal och ändra till den tidigare kontrollerade calibre-kodmappen, 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 src och undermapparna för resurser. Kommandoradsverktygen för calibre finns i calibre-appaketet, i :file:`/Applications/calibre.app/Contents/MacOS` bör du lägga till den här mappen till din PATH-miljövariabel, 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 kommer att ställa in miljövariabeln ``CALIBRE_DEVELOP_FROM`` till 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 fil med oformaterad text::

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: Du bör se en del diagnostisk information i terminalfönstret när calibre startar, och du bör se en asterisk efter versionsnumret i grafiska gränssnittsfönstret, vilket indikerar att du kör från källkod.

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 är främst utvecklat i Linux. Du har två val i inrättandet av utvecklingsmiljön. Du kan installera calibre-binär som vanligt och använda det som en driftstidsmiljö för att göra din utveckling. Detta tillvägagångssätt liknar den som används i Windows och macOS. Alternativt kan du installera calibre från källan. Instruktioner för hur du installerar en utvecklingsmiljö från källan är i installationsfilen i källkodsträdet. Här kommer vi att ta itu med den binär som en körbar, 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: Det rekommenderas att använda det binära installationsprogrammet som tillhandahålls uppströms. Om du insisterar på att använda ett paket som tillhandahålls av din distribution, använd variablerna ``CALIBRE_PYTHON_PATH`` och ``CALIBRE_RESOURCES_PATH`` istället. Du kan få dessa genom att köra ``calibre-debug --paths``. Observera dock att calibre-paket i distributioner ofta är terminalt trasiga och helt ounderstödda.

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: Det är allt! Du är nu redo att börja hacka calibre-koden. Till exempel öppna filen :file:`src/calibre/__init__.py` i din favorit redigerare och lägg till raden::

en: Having separate "normal" and "development" calibre installs on the same computer
sv: Att ha separata "normala"- och "utvecklings"-installationer 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: calibre-källkodsträdet är mycket stabilt och går sällan sönder, men om du känner behov av att köra från källan i ett separat testbibliotek och köra den släppta calibre-versionen med ditt vardagliga bibliotek kan du enkelt uppnå detta med hjälp av .bat-filer eller skalskript för att starta calibre. Exemplet nedan visar hur man gör detta i Windows med .bat-filer (instruktionerna för andra plattformar är desamma, använd bara ett skalskript istället för en .bat-fil)

en: To launch the release version of calibre with your everyday library:
sv: För att starta den utgivna versionen av calibre med ditt vardagliga 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 faciliteter för introspektion. Kovid skrev kärndelar av calibrekod utan en gång med hjälp av ett avlusningsprogram. Det finns många strategier för 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 vid intressanta platser och kör ditt program i terminalen. Till exempel kan du starta det grafiska gränssnittet 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å rader kod för att starta en interaktiv Python-session på den 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 tillgång till alla lokalt definierade variabler (variabler i den lokala omfånget). Den interaktiva prompten har till och med :kbd:`Tab`-komplettering för objektegenskaper och du kan använda de olika Python-faciliteterna för introspektion, såsom :func:`dir`, :func:`type`, :func:`repr` etc.

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, antingen som normalt, eller använda någon av calibre-felsökningskommandon som beskrivs i föregående avsnitt. När ovanstående punkt i koden är nådd kommer calibre frysa, väntar på felsökaren för att 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 man använder Python-felsökaren i `Python stdlib docs 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 kommer fjärrfelsökaren att försöka ansluta på port 4444. Du kan ändra det genom att skicka portparametern till både set_trace()- och cli()-funktionerna 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 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.
sv: Det är möjligt att använda den inbyggda felsökaren i din favorit Python-IDE, om den stöder fjärrfelsökning. Det första steget är att lägga till utcheckat calibre src till ``PYTHONPATH`` i IDE. Med andra ord, mappen du anger som ``CALIBRE_DEVELOP_FROM`` måste ovan, också vara i ``PYTHONPATH`` av din IDE.

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-fjärrfelsökarmodulen i undermappen  :file:`src`för calibre-källkoden. Lägg allt vilken kod som behövs för att starta fjärrfelsökaren i calibre vid intressepunkten, till exempel i huvudfunktionen. Kör sedan 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`ger ett par praktiska flaggor för att köra din egen kod, med tillgång 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 bra för att testa ett litet kodavsnitt på kommandoraden. Det fungerar på samma sätt som den -c flaggan till 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 ditt eget Python-skript. Det fungerar på samma sätt som att skicka skriptet till Python-tolken, förutom att calibre-miljön är helt initierad, så att du kan använda all calibre-kod i skriptet. För att använda kommandoradsargument med ditt skript, använd formuläret::

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: 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 ovanstående teknik, om du gör en källkodsinstallation på Linux, kan du också direkt importera calibre, 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
