# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2024, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-12-04 09:48+0200\n"

"PO-Revision-Date: 2026-02-24 17:44+0200\n"

"Last-Translator: Vassiliki Dalakiari <vdalakiari@gmail.com>\n"

"Language-Team: PyGreece <organizers@pygreece.org>\n"

"Language: el\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: reference/import.rst:6

msgid "The import system"

msgstr "Το σύστημα εισαγωγής"

#: reference/import.rst:10

msgid ""

"Python code in one :term:`module` gains access to the code in another module "

"by the process of :term:`importing` it. The :keyword:`import` statement is "

"the most common way of invoking the import machinery, but it is not the only "

"way. Functions such as :func:`importlib.import_module` and built-in :func:"

"`__import__` can also be used to invoke the import machinery."

msgstr ""

"Ο κώδικας Python σε ένα :term:`module` αποκτά πρόσβαση στον κώδικα ενός "

"άλλου module μέσω της διαδικασίας του :term:`importing`. Η δήλωση :keyword:"

"`import` είναι ο πιο συνηθισμένος τρόπος ενεργοποίησης του μηχανισμού "

"import, αλλά δεν είναι ο μόνος. Συναρτήσεις όπως η :func:`importlib."

"import_module` και η ενσωματωμένη :func:`__import__` μπορούν επίσης να "

"χρησιμοποιηθούν για την ενεργοποίηση του μηχανισμού εισαγωγής."

#: reference/import.rst:16

msgid ""

"The :keyword:`import` statement combines two operations; it searches for the "

"named module, then it binds the results of that search to a name in the "

"local scope. The search operation of the :keyword:`!import` statement is "

"defined as a call to the :func:`__import__` function, with the appropriate "

"arguments. The return value of :func:`__import__` is used to perform the "

"name binding operation of the :keyword:`!import` statement. See the :"

"keyword:`!import` statement for the exact details of that name binding "

"operation."

msgstr ""

"Η δήλωση :keyword:`import` συνδυάζει δύο λειτουργίες· αναζητά το module με "

"το συγκεκριμένο όνομα και στη συνέχεια συνδέει τα αποτελέσματα αυτής της "

"αναζήτησης σε ένα όνομα στο τοπικό scope. Η λειτουργία αναζήτησης της "

"δήλωσης :keyword:`!import` ορίζεται ως κλήση της συνάρτησης :func:"

"`__import__`, με τα κατάλληλα ορίσματα. Η τιμή επιστροφής της :func:"

"`__import__` χρησιμοποιείται για να εκτελεστεί η λειτουργία δέσμευσης "

"ονόματος της δήλωσης :keyword:`!import`. Δείτε τη δήλωση :keyword:`!import` "

"για τις ακριβείς λεπτομέρειες αυτής της λειτουργίας."

#: reference/import.rst:25

msgid ""

"A direct call to :func:`__import__` performs only the module search and, if "

"found, the module creation operation. While certain side-effects may occur, "

"such as the importing of parent packages, and the updating of various caches "

"(including :data:`sys.modules`), only the :keyword:`import` statement "

"performs a name binding operation."

msgstr ""

"Μια άμεση κλήση της :func:`__import__` εκτελεί μόνο την αναζήτηση του module "

"και, αν βρεθεί, τη λειτουργία δημιουργίας του. Παρότι μπορεί να προκύψουν "

"ορισμένες παρενέργειες, όπως η εισαγωγή των γονικών πακέτων και η ενημέρωση "

"διάφορων προσωρινών μνημών (συμπεριλαμβανομένου του :data:`sys.modules`), "

"μόνο η δήλωση :keyword:`import` εκτελεί λειτουργία δέσμευσης ονόματος."

#: reference/import.rst:31

msgid ""

"When an :keyword:`import` statement is executed, the standard builtin :func:"

"`__import__` function is called. Other mechanisms for invoking the import "

"system (such as :func:`importlib.import_module`) may choose to bypass :func:"

"`__import__` and use their own solutions to implement import semantics."

msgstr ""

"Όταν εκτελείται μια δήλωση :keyword:`import`, καλείται η τυπική ενσωματωμένη "

"συνάρτηση :func:`__import__`. Άλλοι μηχανισμοί ενεργοποίησης του συστήματος "

"εισαγωγής (όπως η :func:`importlib.import_module`) μπορεί να επιλέξουν να "

"παρακάμψουν τη :func:`__import__` και να χρησιμοποιήσουν δικές τους λύσεις "

"για την υλοποίηση της σημασιολογίας της εισαγωγής."

#: reference/import.rst:36

msgid ""

"When a module is first imported, Python searches for the module and if "

"found, it creates a module object [#fnmo]_, initializing it. If the named "

"module cannot be found, a :exc:`ModuleNotFoundError` is raised. Python "

"implements various strategies to search for the named module when the import "

"machinery is invoked. These strategies can be modified and extended by "

"using various hooks described in the sections below."

msgstr ""

"Όταν εισάγεται ένα module για πρώτη φορά, η Python το αναζητά και, αν το "

"βρει, δημιουργεί ένα αντικείμενο module [#fnmo]_, αρχικοποιώντας το. Αν το "

"module με το συγκεκριμένο όνομα δεν μπορεί να βρεθεί, γίνεται raise η "

"εξαίρεση :exc:`ModuleNotFoundError`. Η Python υλοποιεί διάφορες στρατηγικές "

"αναζήτησης για το module όταν ενεργοποιείται ο μηχανισμός εισαγωγής. Αυτές "

"οι στρατηγικές μπορούν να τροποποιηθούν και να επεκταθούν μέσω διάφορων "

"hooks που περιγράφονται στις παρακάτω ενότητες."

#: reference/import.rst:43

msgid ""

"The import system has been updated to fully implement the second phase of :"

"pep:`302`. There is no longer any implicit import machinery - the full "

"import system is exposed through :data:`sys.meta_path`. In addition, native "

"namespace package support has been implemented (see :pep:`420`)."

msgstr ""

"Το σύστημα εισαγωγής έχει ενημερωθεί ώστε να υλοποιεί πλήρως τη δεύτερη φάση "

"του :pep:`302`. Δεν υπάρχει πλέον κανένας έμμεσος μηχανισμός εισαγωγής - ο "

"πλήρης μηχανισμός εισαγωγής εκτίθεται μέσω του :data:`sys.meta_path`. "

"Επιπλέον, έχει υλοποιηθεί εγγενής υποστήριξη για namespace packages (βλ. :"

"pep:`420`)."

#: reference/import.rst:51

msgid ":mod:`importlib`"

msgstr ":mod:`importlib`"

#: reference/import.rst:53

msgid ""

"The :mod:`importlib` module provides a rich API for interacting with the "

"import system. For example :func:`importlib.import_module` provides a "

"recommended, simpler API than built-in :func:`__import__` for invoking the "

"import machinery. Refer to the :mod:`importlib` library documentation for "

"additional detail."

msgstr ""

"Το module :mod:`importlib` παρέχει ένα πλούσιο API για αλληλεπίδραση με το "

"σύστημα εισαγωγής. Για παράδειγμα, η :func:`importlib.import_module` παρέχει "

"ένα προτεινόμενο, απλούστερο API από την ενσωματωμένη :func:`__import__` για "

"την ενεργοποίηση του μηχανισμού εισαγωγής. Ανατρέξτε στην τεκμηρίωση της "

"βιβλιοθήκης :mod:`importlib` για περισσότερες λεπτομέρειες."

#: reference/import.rst:62

msgid "Packages"

msgstr "Πακέτα"

#: reference/import.rst:67

msgid ""

"Python has only one type of module object, and all modules are of this type, "

"regardless of whether the module is implemented in Python, C, or something "

"else. To help organize modules and provide a naming hierarchy, Python has a "

"concept of :term:`packages <package>`."

msgstr ""

"Η Python έχει μόνο έναν τύπο αντικειμένου module, και όλα τα modules είναι "

"αυτού του τύπου, ανεξάρτητα από το αν το module υλοποιείται σε Python, C ή "

"κάτι άλλο. Για να βοηθήσει στην οργάνωση των modules και να παρέχει μια "

"ιεραρχία ονοματοδοσίας, η Python διαθέτει την έννοια των :term:`packages "

"<package>`."

#: reference/import.rst:72

msgid ""

"You can think of packages as the directories on a file system and modules as "

"files within directories, but don't take this analogy too literally since "

"packages and modules need not originate from the file system. For the "

"purposes of this documentation, we'll use this convenient analogy of "

"directories and files. Like file system directories, packages are organized "

"hierarchically, and packages may themselves contain subpackages, as well as "

"regular modules."

msgstr ""

"Μπορείτε να σκεφτείτε τα packages ως φακέλους σε ένα σύστημα αρχείων και τα "

"modules ως αρχεία μέσα σε φακέλους, αλλά μην πάρετε αυτή την αναλογία "

"κυριολεκτικά, καθώς packages και modules δεν είναι απαραίτητο να προέρχονται "

"από το σύστημα αρχείων. Για τους σκοπούς αυτής της τεκμηρίωσης, θα "

"χρησιμοποιήσουμε αυτή τη βολική αναλογία φακέλων και αρχείων. Όπως οι "

"φάκελοι του συστήματος αρχείων, τα packages οργανώνονται ιεραρχικά, και "

"μπορούν να περιέχουν subpackages, καθώς και κανονικά modules."

#: reference/import.rst:80

msgid ""

"It's important to keep in mind that all packages are modules, but not all "

"modules are packages. Or put another way, packages are just a special kind "

"of module. Specifically, any module that contains a ``__path__`` attribute "

"is considered a package."

msgstr ""

"Είναι σημαντικό να έχετε υπόψη ότι όλα τα packages είναι modules, αλλά δεν "

"είναι όλα τα modules packages. Με άλλα λόγια, τα packages είναι απλώς ένας "

"ειδικός τύπος module. Συγκεκριμένα, οποιοδήποτε module περιέχει το "

"χαρακτηριστικό ``__path__`` θεωρείται package."

#: reference/import.rst:85

msgid ""

"All modules have a name. Subpackage names are separated from their parent "

"package name by a dot, akin to Python's standard attribute access syntax. "

"Thus you might have a package called :mod:`email`, which in turn has a "

"subpackage called :mod:`email.mime` and a module within that subpackage "

"called :mod:`email.mime.text`."

msgstr ""

"Όλα τα modules έχουν ένα όνομα. Τα ονόματα των subpackages διαχωρίζονται από "

"το όνομα του γονικού package με τελεία, αντίστοιχα με τη συνηθισμένη σύνταξη "

"πρόσβασης σε χαρακτηριστικά στην Python. Έτσι, μπορεί να έχετε ένα package "

"με όνομα :mod:`email`, το οποίο με τη σειρά του έχει ένα subpackage με "

"όνομα :mod:`email.mime` και ένα module μέσα σε αυτό το subpackage με όνομα :"

"mod:`email.mime.text`."

#: reference/import.rst:93

msgid "Regular packages"

msgstr "Κανονικά πακέτα"

#: reference/import.rst:98

msgid ""

"Python defines two types of packages, :term:`regular packages <regular "

"package>` and :term:`namespace packages <namespace package>`. Regular "

"packages are traditional packages as they existed in Python 3.2 and earlier. "

"A regular package is typically implemented as a directory containing an "

"``__init__.py`` file. When a regular package is imported, this ``__init__."

"py`` file is implicitly executed, and the objects it defines are bound to "

"names in the package's namespace. The ``__init__.py`` file can contain the "

"same Python code that any other module can contain, and Python will add some "

"additional attributes to the module when it is imported."

msgstr ""

"Η Python ορίζει δύο τύπους packages: τα :term:`regular packages <regular "

"package>` και τα :term:`namespace packages <namespace package>`. Τα regular "

"packages είναι τα παραδοσιακά packages όπως υπήρχαν στην Python 3.2 και "

"παλαιότερα. Ένα regular package υλοποιείται συνήθως ως φάκελος που περιέχει "

"ένα αρχείο ``__init__.py``. Όταν εισάγεται ένα regular package, το αρχείο "

"``__init__.py`` εκτελείται έμμεσα, και τα αντικείμενα που ορίζει δεσμεύονται "

"σε ονόματα στο namespace του package. Το ``__init__.py`` μπορεί να περιέχει "

"τον ίδιο κώδικα Python που μπορεί να περιέχει οποιοδήποτε άλλο module, και η "

"Python θα προσθέσει ορισμένα επιπλέον χαρακτηριστικά στο module όταν "

"εισάγεται."

#: reference/import.rst:108

msgid ""

"For example, the following file system layout defines a top level ``parent`` "

"package with three subpackages::"

msgstr ""

"Για παράδειγμα, η ακόλουθη διάταξη στο σύστημα αρχείων ορίζει ένα package "

"ανωτέρου επιπέδου ``parent`` με τρία subpackages::"

#: reference/import.rst:111

msgid ""

"parent/\n"

" __init__.py\n"

" one/\n"

" __init__.py\n"

" two/\n"

" __init__.py\n"

" three/\n"

" __init__.py"

msgstr ""

"parent/\n"

" __init__.py\n"

" one/\n"

" __init__.py\n"

" two/\n"

" __init__.py\n"

" three/\n"

" __init__.py"

#: reference/import.rst:120

msgid ""

"Importing ``parent.one`` will implicitly execute ``parent/__init__.py`` and "

"``parent/one/__init__.py``. Subsequent imports of ``parent.two`` or "

"``parent.three`` will execute ``parent/two/__init__.py`` and ``parent/three/"

"__init__.py`` respectively."

msgstr ""

"Η εισαγωγή του ``parent.one`` θα εκτελέσει έμμεσα τα ``parent/__init__.py`` "

"και ``parent/one/__init__.py``. Μετέπειτα εισαγωγές του ``parent.two`` ή του "

"``parent.three`` θα εκτελέσουν τα ``parent/two/__init__.py`` και ``parent/"

"three/__init__.py`` αντίστοιχα."

#: reference/import.rst:129

msgid "Namespace packages"

msgstr "Namespace πακέτα"

#: reference/import.rst:135

msgid ""

"A namespace package is a composite of various :term:`portions <portion>`, "

"where each portion contributes a subpackage to the parent package. Portions "

"may reside in different locations on the file system. Portions may also be "

"found in zip files, on the network, or anywhere else that Python searches "

"during import. Namespace packages may or may not correspond directly to "

"objects on the file system; they may be virtual modules that have no "

"concrete representation."

msgstr ""

"Ένα namespace πακέτο είναι ένας συνδυασμός από διάφορα :term:`portions "

"<portion>`, όπου κάθε portion συνεισφέρει ένα subpackage στο γονικό πακέτο. "

"Τα portions μπορεί να βρίσκονται σε διαφορετικές τοποθεσίες στο σύστημα "

"αρχείων. Μπορεί επίσης να βρίσκονται σε zip αρχεία, στο δίκτυο ή οπουδήποτε "

"αλλού αναζητά η Python κατά την εισαγωγή. Τα namespace πακέτα μπορεί να "

"αντιστοιχούν ή να μην αντιστοιχούν άμεσα σε αντικείμενα στο σύστημα αρχείων· "

"μπορεί να είναι «εικονικά» modules που δεν έχουν συγκεκριμένη φυσική "

"αναπαράσταση."

#: reference/import.rst:143

msgid ""

"Namespace packages do not use an ordinary list for their ``__path__`` "

"attribute. They instead use a custom iterable type which will automatically "

"perform a new search for package portions on the next import attempt within "

"that package if the path of their parent package (or :data:`sys.path` for a "

"top level package) changes."

msgstr ""

"Τα namespace πακέτα δεν χρησιμοποιούν μια συνηθισμένη λίστα για το "

"χαρακτηριστικό ``__path__``. Αντί γι’ αυτό χρησιμοποιούν έναν προσαρμοσμένο "

"iterable τύπο, ο οποίος θα εκτελέσει αυτόματα μία νέα αναζήτηση για portions "

"του πακέτου στην επόμενη προσπάθεια εισαγωγής μέσα σε αυτό το πακέτο, αν "

"αλλάξει το path του γονικού πακέτου (ή το :data:`sys.path` για πακέτο "

"ανωτέρου επιπέδου)."

#: reference/import.rst:149

msgid ""

"With namespace packages, there is no ``parent/__init__.py`` file. In fact, "

"there may be multiple ``parent`` directories found during import search, "

"where each one is provided by a different portion. Thus ``parent/one`` may "

"not be physically located next to ``parent/two``. In this case, Python will "

"create a namespace package for the top-level ``parent`` package whenever it "

"or one of its subpackages is imported."

msgstr ""

"Με τα namespace πακέτα, δεν υπάρχει αρχείο ``parent/__init__.py``. Στην "

"πράξη, μπορεί να βρεθούν πολλοί φάκελοι ``parent`` κατά την αναζήτηση "

"εισαγωγής, όπου ο καθένας παρέχεται από διαφορετικό portion. Έτσι, το "

"``parent/one`` ενδέχεται να μην βρίσκεται φυσικά δίπλα στο ``parent/two``. "

"Σε αυτή την περίπτωση, η Python θα δημιουργήσει ένα namespace πακέτο για το "

"πακέτο ανωτέρου επιπέδου ``parent`` κάθε φορά που γίνεται εισαγωγή αυτού ή "

"κάποιου από τα subpackages του."

#: reference/import.rst:156

msgid "See also :pep:`420` for the namespace package specification."

msgstr "Δείτε επίσης το :pep:`420` για την προδιαγραφή των namespace πακέτων."

#: reference/import.rst:160

msgid "Searching"

msgstr "Αναζήτηση"

#: reference/import.rst:162

msgid ""

"To begin the search, Python needs the :term:`fully qualified <qualified "

"name>` name of the module (or package, but for the purposes of this "

"discussion, the difference is immaterial) being imported. This name may "

"come from various arguments to the :keyword:`import` statement, or from the "

"parameters to the :func:`importlib.import_module` or :func:`__import__` "

"functions."

msgstr ""

"Για να ξεκινήσει η αναζήτηση, η Python χρειάζεται το :term:`πλήρως "

"αναγνωρισμένο <qualified name>` όνομα του module (ή του πακέτου, αλλά για "

"τους σκοπούς αυτής της συζήτησης η διαφορά δεν έχει σημασία) που εισάγεται. "

"Αυτό το όνομα μπορεί να προέρχεται από διάφορα ορίσματα της δήλωσης :keyword:"

"`import` ή από τις παραμέτρους των συναρτήσεων :func:`importlib."

"import_module` ή :func:`__import__`."

#: reference/import.rst:168

msgid ""

"This name will be used in various phases of the import search, and it may be "

"the dotted path to a submodule, e.g. ``foo.bar.baz``. In this case, Python "

"first tries to import ``foo``, then ``foo.bar``, and finally ``foo.bar."

"baz``. If any of the intermediate imports fail, a :exc:`ModuleNotFoundError` "

"is raised."

msgstr ""

"Αυτό το όνομα θα χρησιμοποιηθεί σε διάφορες φάσεις της αναζήτησης import και "

"μπορεί να είναι μια διαδρομή με τελείες προς ένα submodule, π.χ. ``foo.bar."

"baz``. Σε αυτή την περίπτωση, η Python πρώτα προσπαθεί να εισάγει το "

"``foo``, μετά το ``foo.bar`` και τέλος το ``foo.bar.baz``. Αν αποτύχει "

"κάποιες από τις ενδιάμεσες εισαγωγές, γίνεται raise η :exc:"

"`ModuleNotFoundError`."

#: reference/import.rst:175

msgid "The module cache"

msgstr "Η προσωρινή μνήμη του module"

#: reference/import.rst:180

msgid ""

"The first place checked during import search is :data:`sys.modules`. This "

"mapping serves as a cache of all modules that have been previously imported, "

"including the intermediate paths. So if ``foo.bar.baz`` was previously "

"imported, :data:`sys.modules` will contain entries for ``foo``, ``foo.bar``, "

"and ``foo.bar.baz``. Each key will have as its value the corresponding "

"module object."

msgstr ""

"Το πρώτο σημείο που ελέγχεται κατά την αναζήτηση εισαγωγής είναι το :data:"

"`sys.modules`. Αυτή η αντιστοίχιση λειτουργεί ως προσωρινή μνήμη όλων των "

"modules που έχουν εισαχθεί στο παρελθόν, συμπεριλαμβανομένων των ενδιάμεσων "

"διαδρομών. Έτσι, αν το ``foo.bar.baz`` είχε εισαχθεί προηγουμένως, το :data:"

"`sys.modules` θα περιέχει εγγραφές για τα ``foo``, ``foo.bar`` και ``foo.bar."

"baz``. Κάθε κλειδί θα έχει ως τιμή το αντίστοιχο αντικείμενο module."

#: reference/import.rst:187

msgid ""

"During import, the module name is looked up in :data:`sys.modules` and if "

"present, the associated value is the module satisfying the import, and the "

"process completes. However, if the value is ``None``, then a :exc:"

"`ModuleNotFoundError` is raised. If the module name is missing, Python will "

"continue searching for the module."

msgstr ""

"Κατά την εισαγωγή, το όνομα του module αναζητείται στο :data:`sys.modules` "

"και, αν υπάρχει, η συσχετισμένη τιμή είναι το module που ικανοποιεί την "

"εισαγωγή και η διαδικασία ολοκληρώνεται. Ωστόσο, αν η τιμή είναι ``None``, "

"τότε γίνεται raise το :exc:`ModuleNotFoundError`. Αν το όνομα του module "

"λείπει, η Python θα συνεχίσει να αναζητά το module."

#: reference/import.rst:193

msgid ""

":data:`sys.modules` is writable. Deleting a key may not destroy the "

"associated module (as other modules may hold references to it), but it will "

"invalidate the cache entry for the named module, causing Python to search "

"anew for the named module upon its next import. The key can also be assigned "

"to ``None``, forcing the next import of the module to result in a :exc:"

"`ModuleNotFoundError`."

msgstr ""

"Το :data:`sys.modules` είναι εγγράψιμο. Η διαγραφή ενός κλειδιού μπορεί να "

"μην καταστρέψει το αντίστοιχο module (καθώς άλλα modules μπορεί να κρατούν "

"αναφορές σε αυτό), αλλά θα ακυρώσει την εγγραφή της προσωρινής μνήμης για το "

"module με το συγκεκριμένο όνομα, προκαλώντας την Python να το αναζητήσει "

"ξανά στην επόμενο εισαγωγή. Το κλειδί μπορεί επίσης να οριστεί σε ``None``, "

"αναγκάζοντας την επόμενο εισαγωγή του module να καταλήξει σε :exc:"

"`ModuleNotFoundError`."

#: reference/import.rst:200

msgid ""

"Beware though, as if you keep a reference to the module object, invalidate "

"its cache entry in :data:`sys.modules`, and then re-import the named module, "

"the two module objects will *not* be the same. By contrast, :func:`importlib."

"reload` will reuse the *same* module object, and simply reinitialise the "

"module contents by rerunning the module's code."

msgstr ""

"Προσοχή όμως: αν κρατήσετε μια αναφορά στο αντικείμενο module, ακυρώσετε την "

"εγγραφή του στην προσωρινή μνήμη του :data:`sys.modules` και μετά ξανακάνετε "

"εισαγωγή το module με το ίδιο όνομα, τα δύο αντικείμενα module *δεν* θα "

"είναι τα ίδια. Αντίθετα, η :func:`importlib.reload` θα επαναχρησιμοποιήσει "

"το *ίδιο* αντικείμενο module και απλώς θα επαναρχικοποιήσει τα περιεχόμενά "

"του εκτελώντας ξανά τον κώδικα του module."

#: reference/import.rst:210

msgid "Finders and loaders"

msgstr "Finders και loaders"

#: reference/import.rst:217

msgid ""

"If the named module is not found in :data:`sys.modules`, then Python's "

"import protocol is invoked to find and load the module. This protocol "

"consists of two conceptual objects, :term:`finders <finder>` and :term:"

"`loaders <loader>`. A finder's job is to determine whether it can find the "

"named module using whatever strategy it knows about. Objects that implement "

"both of these interfaces are referred to as :term:`importers <importer>` - "

"they return themselves when they find that they can load the requested "

"module."

msgstr ""

"Αν το module με το συγκεκριμένο όνομα δεν βρεθεί στο :data:`sys.modules`, "

"τότε ενεργοποιείται το πρωτόκολλο εισαγωγής της Python για να βρεθεί και να "

"φορτωθεί το module. Αυτό το πρωτόκολλο αποτελείται από δύο εννοιολογικά "

"αντικείμενα: :term:`finders <finder>` και :term:`loaders <loader>`. Ο ρόλος "

"ενός finder είναι να καθορίσει αν μπορεί να βρει το module με το "

"συγκεκριμένο όνομα, χρησιμοποιώντας όποια στρατηγική γνωρίζει. Αντικείμενα "

"που υλοποιούν και τις δύο αυτές διεπαφές αναφέρονται ως :term:`importers "

"<importer>` - επιστρέφουν τον εαυτό τους όταν διαπιστώσουν ότι μπορούν να "

"φορτώσουν το ζητούμενο module."

#: reference/import.rst:225

msgid ""

"Python includes a number of default finders and importers. The first one "

"knows how to locate built-in modules, and the second knows how to locate "

"frozen modules. A third default finder searches an :term:`import path` for "

"modules. The :term:`import path` is a list of locations that may name file "

"system paths or zip files. It can also be extended to search for any "

"locatable resource, such as those identified by URLs."

msgstr ""

"Η Python περιλαμβάνει αρκετούς προεπιλεγμένους finders και importers. Το "

"πρώτο γνωρίζει πώς να εντοπίζει built-in modules, και το δεύτερο πώς να "

"εντοπίζει παγωμένα (frozen) modules. Ένας τρίτος προεπιλεγμένος finder "

"αναζητά modules σε ένα :term:`import path`. Το :term:`import path` είναι μια "

"λίστα από τοποθεσίες που μπορεί να είναι διαδρομές του συστήματος αρχείων ή "

"zip αρχεία. Μπορεί επίσης να επεκταθεί ώστε να αναζητά οποιονδήποτε "

"εντοπίσιμο πόρο, όπως αυτούς που προσδιορίζονται από URLs."

#: reference/import.rst:232

msgid ""

"The import machinery is extensible, so new finders can be added to extend "

"the range and scope of module searching."

msgstr ""

"Ο μηχανισμός εισαγωγής είναι επεκτάσιμος, επομένως μπορούν να προστεθούν "

"νέοι finders ώστε να επεκταθεί το εύρος και η κάλυψη της αναζήτησης των "

"modules."

#: reference/import.rst:235

msgid ""

"Finders do not actually load modules. If they can find the named module, "

"they return a :dfn:`module spec`, an encapsulation of the module's import-"

"related information, which the import machinery then uses when loading the "

"module."

msgstr ""

"Οι finders δεν φορτώνουν πραγματικά τα modules. Αν μπορούν να βρουν το "

"module με το συγκεκριμένο όνομα, επιστρέφουν ένα :dfn:`module spec`, δηλαδή "

"μια ενθυλάκωση της πληροφορίας που σχετίζεται με την εισαγωγή του module, "

"την οποία ο μηχανισμός εισαγωγής χρησιμοποιεί στη συνέχεια για να φορτώσει "

"το module."

#: reference/import.rst:239

msgid ""

"The following sections describe the protocol for finders and loaders in more "

"detail, including how you can create and register new ones to extend the "

"import machinery."

msgstr ""

"Οι ακόλουθες ενότητες περιγράφουν πιο αναλυτικά το πρωτόκολλο για finders "

"και loaders, συμπεριλαμβανομένου του πώς μπορείτε να δημιουργήσετε και να "

"καταχωρίσετε νέους, ώστε να επεκτείνετε τον μηχανισμό εισαγωγής."

#: reference/import.rst:243

msgid ""

"In previous versions of Python, finders returned :term:`loaders <loader>` "

"directly, whereas now they return module specs which *contain* loaders. "

"Loaders are still used during import but have fewer responsibilities."

msgstr ""

"Σε παλαιότερες εκδόσεις της Python, οι finders επέστρεφαν απευθείας :term:"

"`loaders <loader>`, ενώ τώρα επιστρέφουν module specs που *περιέχουν* "

"loaders. Οι loaders εξακολουθούν να χρησιμοποιούνται κατά την εισαγωγή, αλλά "

"έχουν λιγότερες ευθύνες."

#: reference/import.rst:249

msgid "Import hooks"

msgstr "Εισαγωγή hooks"

#: reference/import.rst:259

msgid ""

"The import machinery is designed to be extensible; the primary mechanism for "

"this are the *import hooks*. There are two types of import hooks: *meta "

"hooks* and *import path hooks*."

msgstr ""

"Ο μηχανισμός εισαγωγής είναι σχεδιασμένος ώστε να είναι επεκτάσιμος· ο "

"βασικός μηχανισμός για αυτό είναι η *εισαγωγή hooks*. Υπάρχουν δύο τύποι "

"εισαγωγής hooks: *meta hooks* και *import path hooks*."

#: reference/import.rst:263

msgid ""

"Meta hooks are called at the start of import processing, before any other "

"import processing has occurred, other than :data:`sys.modules` cache look "

"up. This allows meta hooks to override :data:`sys.path` processing, frozen "

"modules, or even built-in modules. Meta hooks are registered by adding new "

"finder objects to :data:`sys.meta_path`, as described below."

msgstr ""

"Τα meta hooks καλούνται στην αρχή της επεξεργασίας εισαγωγής, πριν συμβεί "

"οποιαδήποτε άλλη επεξεργασία εισαγωγής, εκτός από την αναζήτηση στην "

"προσωρινή μνήμη του :data:`sys.modules`. Αυτό επιτρέπει στα meta hooks να "

"υπερκαλύπτουν την επεξεργασία του :data:`sys.path`, τα παγωμένα modules ή "

"ακόμη και τα built-in modules. Τα meta hooks καταχωρίζονται προσθέτοντας νέα "

"αντικείμενα finder στο :data:`sys.meta_path`, όπως περιγράφεται παρακάτω."

#: reference/import.rst:269

msgid ""

"Import path hooks are called as part of :data:`sys.path` (or ``package."

"__path__``) processing, at the point where their associated path item is "

"encountered. Import path hooks are registered by adding new callables to :"

"data:`sys.path_hooks` as described below."

msgstr ""

"Τα import path hooks καλούνται ως μέρος της επεξεργασίας του :data:`sys."

"path` (ή του ``package.__path__``), στο σημείο όπου συναντάται το αντίστοιχο "

"στοιχείο διαδρομής. Τα import path hooks καταχωρίζονται προσθέτοντας νέα "

"callables στο :data:`sys.path_hooks`, όπως περιγράφεται παρακάτω."

#: reference/import.rst:276

msgid "The meta path"

msgstr "Το meta path"

#: reference/import.rst:282

msgid ""

"When the named module is not found in :data:`sys.modules`, Python next "

"searches :data:`sys.meta_path`, which contains a list of meta path finder "

"objects. These finders are queried in order to see if they know how to "

"handle the named module. Meta path finders must implement a method called :"

"meth:`~importlib.abc.MetaPathFinder.find_spec` which takes three arguments: "

"a name, an import path, and (optionally) a target module. The meta path "

"finder can use any strategy it wants to determine whether it can handle the "

"named module or not."

msgstr ""

"Όταν το module με το συγκεκριμένο όνομα δεν βρεθεί στο :data:`sys.modules`, "

"η Python στη συνέχεια το αναζητά στο :data:`sys.meta_path`, το οποίο "

"περιέχει μια λίστα από meta path finder αντικείμενα. Αυτοί οι finders "

"ερωτώνται με τη σειρά για να διαπιστωθεί αν γνωρίζουν πώς να χειριστούν το "

"module. Οι meta path finders πρέπει να υλοποιούν μια μέθοδο με όνομα :meth:"

"`~importlib.abc.MetaPathFinder.find_spec`, η οποία λαμβάνει τρία ορίσματα: "

"ένα όνομα, ένα import path και (προαιρετικά) ένα target module. Ο meta path "

"finder μπορεί να χρησιμοποιήσει οποιαδήποτε στρατηγική θέλει για να "

"καθορίσει αν μπορεί να χειριστεί το module ή όχι."

#: reference/import.rst:291

msgid ""

"If the meta path finder knows how to handle the named module, it returns a "

"spec object. If it cannot handle the named module, it returns ``None``. "

"If :data:`sys.meta_path` processing reaches the end of its list without "

"returning a spec, then a :exc:`ModuleNotFoundError` is raised. Any other "

"exceptions raised are simply propagated up, aborting the import process."

msgstr ""

"Αν ο meta path finder γνωρίζει πώς να χειριστεί το module, επιστρέφει ένα "

"spec αντικείμενο. Αν δεν μπορεί να χειριστεί το module, επιστρέφει ``None``. "

"Αν η επεξεργασία του :data:`sys.meta_path` φτάσει στο τέλος της λίστας χωρίς "

"να επιστραφεί spec, τότε γίνεται raise το :exc:`ModuleNotFoundError`. "

"Οποιεσδήποτε άλλες εξαιρέσεις γίνονται raise απλώς προωθούνται προς τα πάνω, "

"τερματίζοντας τη διαδικασία εισαγωγής."

#: reference/import.rst:297

msgid ""

"The :meth:`~importlib.abc.MetaPathFinder.find_spec` method of meta path "

"finders is called with two or three arguments. The first is the fully "

"qualified name of the module being imported, for example ``foo.bar.baz``. "

"The second argument is the path entries to use for the module search. For "

"top-level modules, the second argument is ``None``, but for submodules or "

"subpackages, the second argument is the value of the parent package's "

"``__path__`` attribute. If the appropriate ``__path__`` attribute cannot be "

"accessed, a :exc:`ModuleNotFoundError` is raised. The third argument is an "

"existing module object that will be the target of loading later. The import "

"system passes in a target module only during reload."

msgstr ""

"Η μέθοδος :meth:`~importlib.abc.MetaPathFinder.find_spec` των meta path "

"finders καλείται με δύο ή τρία ορίσματα. Το πρώτο είναι το πλήρως "

"αναγνωρισμένο όνομα του module που εισάγεται, π.χ. ``foo.bar.baz``. Το "

"δεύτερο όρισμα είναι οι καταχωρήσεις διαδρομής που θα χρησιμοποιηθούν για "

"την αναζήτηση του module. Για modules ανωτέρου επιπέδου, το δεύτερο όρισμα "

"είναι ``None``, αλλά για submodules ή subpackages, είναι η τιμή του "

"χαρακτηριστικού ``__path__`` του γονικού πακέτου. Αν δεν είναι δυνατή η "

"πρόσβαση στο κατάλληλο ``__path__``, γίνεται raise το :exc:"

"`ModuleNotFoundError`. Το τρίτο όρισμα είναι ένα υπάρχον αντικείμενο module "

"που θα αποτελέσει αργότερα τον στόχο της φόρτωσης. Το σύστημα εισαγωγής "

"περνά target module μόνο κατά την επαναφόρτωση."

#: reference/import.rst:308

msgid ""

"The meta path may be traversed multiple times for a single import request. "

"For example, assuming none of the modules involved has already been cached, "

"importing ``foo.bar.baz`` will first perform a top level import, calling "

"``mpf.find_spec(\"foo\", None, None)`` on each meta path finder (``mpf``). "

"After ``foo`` has been imported, ``foo.bar`` will be imported by traversing "

"the meta path a second time, calling ``mpf.find_spec(\"foo.bar\", foo."

"__path__, None)``. Once ``foo.bar`` has been imported, the final traversal "

"will call ``mpf.find_spec(\"foo.bar.baz\", foo.bar.__path__, None)``."

msgstr ""

"Το meta path μπορεί να διασχιστεί πολλές φορές για ένα μόνο αίτημα "

"εισαγωγής. Για παράδειγμα, υποθέτοντας ότι κανένα από τα εμπλεκόμενα modules "

"δεν έχει ήδη προστεθεί στην προσωρινή μνήμη, η εισαγωγή του ``foo.bar.baz`` "

"θα εκτελέσει πρώτα μία εισαγωγή ανωτέρου επιπέδου, καλώντας το ``mpf."

"find_spec(\"foo\", None, None)`` σε κάθε meta path finder (``mpf``). Αφού "

"εισαχθεί το ``foo``, το ``foo.bar`` θα εισαχθεί διασχίζοντας το meta path "

"για δεύτερη φορά, καλώντας την ``mpf.find_spec(\"foo.bar\", foo.__path__, "

"None)``. Μόλις γίνει η εισαγωγή του ``foo.bar``, η τελική διάσχιση θα "

"καλέσει το ``mpf.find_spec(\"foo.bar.baz\", foo.bar.__path__, None)``."

#: reference/import.rst:318

msgid ""

"Some meta path finders only support top level imports. These importers will "

"always return ``None`` when anything other than ``None`` is passed as the "

"second argument."

msgstr ""

"Ορισμένοι meta path finders υποστηρίζουν μόνο εισαγωγές ανωτέρου επιπέδου. "

"Αυτοί οι importers θα επιστρέφουν πάντα ``None`` όταν ως δεύτερο όρισμα "

"περάσει οτιδήποτε άλλο εκτός από ``None``."

#: reference/import.rst:322

msgid ""

"Python's default :data:`sys.meta_path` has three meta path finders, one that "

"knows how to import built-in modules, one that knows how to import frozen "

"modules, and one that knows how to import modules from an :term:`import "

"path` (i.e. the :term:`path based finder`)."

msgstr ""

"Το προεπιλεγμένο :data:`sys.meta_path` της Python έχει τρεις meta path "

"finders: έναν που γνωρίζει πώς να εισάγει ενσωματωμένα modules, έναν που "

"γνωρίζει πώς να εισάγει παγωμένα modules, και έναν που γνωρίζει πώς να "

"εισάγει modules από ένα :term:`import path` (δηλ. τον :term:`path based "

"finder`)."

#: reference/import.rst:327

msgid ""

"The :meth:`~importlib.abc.MetaPathFinder.find_spec` method of meta path "

"finders replaced :meth:`!find_module`, which is now deprecated. While it "

"will continue to work without change, the import machinery will try it only "

"if the finder does not implement :meth:`~importlib.abc.MetaPathFinder."

"find_spec`."

msgstr ""

"Η μέθοδος :meth:`~importlib.abc.MetaPathFinder.find_spec` των meta path "

"finders αντικατέστησε τη :meth:`!find_module`, η οποία πλέον χαρακτηριστεί "

"ως απαρχαιωμένη. Αν και θα συνεχίσει να λειτουργεί χωρίς αλλαγές, ο "

"μηχανισμός εισαγωγής θα τη δοκιμάζει μόνο αν ο finder δεν υλοποιεί τη :meth:"

"`~importlib.abc.MetaPathFinder.find_spec`."

#: reference/import.rst:334

msgid ""

"Use of :meth:`!find_module` by the import system now raises :exc:"

"`ImportWarning`."

msgstr ""

"Η χρήση της :meth:`!find_module` από το σύστημα εισαγωγής πλέον κάνει raise "

"την :exc:`ImportWarning`."

#: reference/import.rst:338

msgid ""

":meth:`!find_module` has been removed. Use :meth:`~importlib.abc."

"MetaPathFinder.find_spec` instead."

msgstr ""

"Η :meth:`!find_module` έχει αφαιρεθεί. Χρησιμοποιήστε την :meth:`~importlib."

"abc.MetaPathFinder.find_spec` στη θέση της."

#: reference/import.rst:344

msgid "Loading"

msgstr "Φόρτωση"

#: reference/import.rst:346

msgid ""

"If and when a module spec is found, the import machinery will use it (and "

"the loader it contains) when loading the module. Here is an approximation "

"of what happens during the loading portion of import::"

msgstr ""

"Αν και όταν βρεθεί ένα module spec, ο μηχανισμός εισαγωγής θα το "

"χρησιμοποιήσει (και τον loader που περιέχει) για να φορτώσει το module. "

"Ακολουθεί μια προσέγγιση του τι συμβαίνει στο στάδιο φόρτωσης του import::"

#: reference/import.rst:350

msgid ""

"module = None\n"

"if spec.loader is not None and hasattr(spec.loader, 'create_module'):\n"

" # It is assumed 'exec_module' will also be defined on the loader.\n"

" module = spec.loader.create_module(spec)\n"

"if module is None:\n"

" module = ModuleType(spec.name)\n"

"# The import-related module attributes get set here:\n"

"_init_module_attrs(spec, module)\n"

"\n"

"if spec.loader is None:\n"

" # unsupported\n"

" raise ImportError\n"

"if spec.origin is None and spec.submodule_search_locations is not None:\n"

" # namespace package\n"

" sys.modules[spec.name] = module\n"

"elif not hasattr(spec.loader, 'exec_module'):\n"

" module = spec.loader.load_module(spec.name)\n"

"else:\n"

" sys.modules[spec.name] = module\n"

" try:\n"

" spec.loader.exec_module(module)\n"

" except BaseException:\n"

" try:\n"

" del sys.modules[spec.name]\n"

" except KeyError:\n"

" pass\n"

" raise\n"

"return sys.modules[spec.name]"

msgstr ""

"module = None\n"

"if spec.loader is not None and hasattr(spec.loader, 'create_module'):\n"

" # It is assumed 'exec_module' will also be defined on the loader.\n"

" module = spec.loader.create_module(spec)\n"

"if module is None:\n"

" module = ModuleType(spec.name)\n"

"# The import-related module attributes get set here:\n"

"_init_module_attrs(spec, module)\n"

"\n"

"if spec.loader is None:\n"

" # unsupported\n"

" raise ImportError\n"

"if spec.origin is None and spec.submodule_search_locations is not None:\n"

" # namespace package\n"

" sys.modules[spec.name] = module\n"

"elif not hasattr(spec.loader, 'exec_module'):\n"

" module = spec.loader.load_module(spec.name)\n"

"else:\n"

" sys.modules[spec.name] = module\n"

" try:\n"

" spec.loader.exec_module(module)\n"

" except BaseException:\n"

" try:\n"

" del sys.modules[spec.name]\n"

" except KeyError:\n"

" pass\n"

" raise\n"

"return sys.modules[spec.name]"

#: reference/import.rst:379

msgid "Note the following details:"

msgstr "Σημειώστε τις ακόλουθες λεπτομέρειες:"

#: reference/import.rst:381

msgid ""

"If there is an existing module object with the given name in :data:`sys."

"modules`, import will have already returned it."

msgstr ""

"Αν υπάρχει ήδη ένα αντικείμενο module με το συγκεκριμένο όνομα στο :data:"

"`sys.modules`, το import θα το έχει ήδη επιστρέψει."

#: reference/import.rst:384

msgid ""

"The module will exist in :data:`sys.modules` before the loader executes the "

"module code. This is crucial because the module code may (directly or "

"indirectly) import itself; adding it to :data:`sys.modules` beforehand "

"prevents unbounded recursion in the worst case and multiple loading in the "

"best."

msgstr ""

"Το module θα υπάρχει στο :data:`sys.modules` πριν ο loader εκτελέσει τον "

"κώδικα του module. Αυτό είναι κρίσιμο, επειδή ο κώδικας του module μπορεί "

"(άμεσα ή έμμεσα) να εισάγει τον εαυτό του· η προσθήκη του στο :data:`sys."

"modules` εκ των προτέρων αποτρέπει ατέρμονη αναδρομή στη χειρότερη περίπτωση "

"και πολλαπλή φόρτωση στην καλύτερη."

#: reference/import.rst:390

msgid ""

"If loading fails, the failing module -- and only the failing module -- gets "

"removed from :data:`sys.modules`. Any module already in the :data:`sys."

"modules` cache, and any module that was successfully loaded as a side-"

"effect, must remain in the cache. This contrasts with reloading where even "

"the failing module is left in :data:`sys.modules`."

msgstr ""

"Αν η φόρτωση αποτύχει, το module που απέτυχε -- και μόνο αυτό -- αφαιρείται "

"από το :data:`sys.modules`. Οποιοδήποτε module βρίσκεται ήδη στην προσωρινή "

"μνήμη του :data:`sys.modules`, καθώς και οποιοδήποτε module φορτώθηκε "

"επιτυχώς ως παρενέργεια, πρέπει να παραμείνει στην προσωρινή μνήμη. Αυτό "

"έρχεται σε αντίθεση με την επαναφόρτωση, όπου ακόμη και το module που "

"αποτυγχάνει παραμένει στο :data:`sys.modules`."

#: reference/import.rst:396

msgid ""

"After the module is created but before execution, the import machinery sets "

"the import-related module attributes (\"_init_module_attrs\" in the pseudo-"

"code example above), as summarized in a :ref:`later section <import-mod-"

"attrs>`."

msgstr ""

"Αφού δημιουργηθεί το module αλλά πριν την εκτέλεση, ο μηχανισμός εισαγωγής "

"ορίζει τα χαρακτηριστικά του module που σχετίζονται με την εισαγωγή "

"(\"_init_module_attrs\" στο παραπάνω παράδειγμα ψευδοκώδικα), όπως "

"συνοψίζεται σε μια :ref:`μεταγενέστερη ενότητα <import-mod-attrs>`."

#: reference/import.rst:401

msgid ""

"Module execution is the key moment of loading in which the module's "

"namespace gets populated. Execution is entirely delegated to the loader, "

"which gets to decide what gets populated and how."

msgstr ""

"Η εκτέλεση του module είναι η κρίσιμη στιγμή της φόρτωσης κατά την οποία "

"γεμίζει το namespace του module. Η εκτέλεση ανατίθεται εξ ολοκλήρου στον "

"loader, ο οποίος αποφασίζει τι θα συμπληρωθεί και με ποιον τρόπο."

#: reference/import.rst:405

msgid ""

"The module created during loading and passed to exec_module() may not be the "

"one returned at the end of import [#fnlo]_."

msgstr ""

"Το module που δημιουργείται κατά τη φόρτωση και περνά στη exec_module() "

"ενδέχεται να μην είναι αυτό που επιστρέφεται στο τέλος του import [#fnlo]_."

#: reference/import.rst:408

msgid ""

"The import system has taken over the boilerplate responsibilities of "

"loaders. These were previously performed by the :meth:`importlib.abc.Loader."

"load_module` method."

msgstr ""

"Το σύστημα εισαγωγής έχει αναλάβει τις τυποποιημένες ευθύνες των loaders. "

"Αυτές εκτελούνταν παλαιότερα από τη μέθοδο :meth:`importlib.abc.Loader."

"load_module`."

#: reference/import.rst:414

msgid "Loaders"

msgstr "Loaders"

#: reference/import.rst:416

msgid ""

"Module loaders provide the critical function of loading: module execution. "

"The import machinery calls the :meth:`importlib.abc.Loader.exec_module` "

"method with a single argument, the module object to execute. Any value "

"returned from :meth:`~importlib.abc.Loader.exec_module` is ignored."

msgstr ""

"Οι module loaders παρέχουν την κρίσιμη λειτουργία της φόρτωσης: την εκτέλεση "

"του module. Ο μηχανισμός εισαγωγής καλεί τη μέθοδο :meth:`importlib.abc."

"Loader.exec_module` με ένα μόνο όρισμα, το αντικείμενο module που θα "

"εκτελεστεί. Οποιαδήποτε τιμή επιστρέφει η :meth:`~importlib.abc.Loader."

"exec_module` αγνοείται."

#: reference/import.rst:421

msgid "Loaders must satisfy the following requirements:"

msgstr "Οι loaders πρέπει να ικανοποιούν τις ακόλουθες απαιτήσεις:"

#: reference/import.rst:423

msgid ""

"If the module is a Python module (as opposed to a built-in module or a "

"dynamically loaded extension), the loader should execute the module's code "

"in the module's global name space (``module.__dict__``)."

msgstr ""

"Αν το module είναι Python module (σε αντίθεση με ένα ενσωματωμένο module ή "

"δυναμικά φορτωμένη επέκταση), ο loader θα πρέπει να εκτελέσει τον κώδικα του "

"module στο καθολικό namespace του module (``module.__dict__``)."

#: reference/import.rst:427

msgid ""

"If the loader cannot execute the module, it should raise an :exc:"

"`ImportError`, although any other exception raised during :meth:`~importlib."

"abc.Loader.exec_module` will be propagated."

msgstr ""

"Αν ο loader δεν μπορεί να εκτελέσει το module, θα πρέπει να κάνει raise το :"

"exc:`ImportError`, αν και οποιαδήποτε άλλη εξαίρεση γίνει raise κατά τη :"

"meth:`~importlib.abc.Loader.exec_module` θα προωθηθεί προς τα πάνω."

#: reference/import.rst:431

msgid ""

"In many cases, the finder and loader can be the same object; in such cases "

"the :meth:`~importlib.abc.MetaPathFinder.find_spec` method would just return "

"a spec with the loader set to ``self``."

msgstr ""

"Σε πολλές περιπτώσεις, ο finder και ο loader μπορεί να είναι το ίδιο "

"αντικείμενο· σε αυτές τις περιπτώσεις, η μέθοδος :meth:`~importlib.abc."

"MetaPathFinder.find_spec` απλώς θα επιστρέψει ένα spec με τον loader "

"ορισμένο σε ``self``."

#: reference/import.rst:435

msgid ""

"Module loaders may opt in to creating the module object during loading by "

"implementing a :meth:`~importlib.abc.Loader.create_module` method. It takes "

"one argument, the module spec, and returns the new module object to use "

"during loading. ``create_module()`` does not need to set any attributes on "

"the module object. If the method returns ``None``, the import machinery "

"will create the new module itself."

msgstr ""

"Οι module loaders μπορούν, προαιρετικά, να δημιουργούν το αντικείμενο module "

"κατά τη φόρτωση υλοποιώντας μια μέθοδο :meth:`~importlib.abc.Loader."

"create_module`. Παίρνει ένα όρισμα, το module spec, και επιστρέφει το νέο "

"αντικείμενο module που θα χρησιμοποιηθεί κατά τη φόρτωση. Η "

"``create_module()`` δεν χρειάζεται να ορίσει χαρακτηριστικά στο αντικείμενο "

"module. Αν η μέθοδος επιστρέψει ``None``, ο μηχανισμός εισαγωγής θα "

"δημιουργήσει ο ίδιος το νέο module."

#: reference/import.rst:442

msgid "The :meth:`~importlib.abc.Loader.create_module` method of loaders."

msgstr "Η μέθοδος :meth:`~importlib.abc.Loader.create_module` των loaders."

#: reference/import.rst:445

msgid ""

"The :meth:`~importlib.abc.Loader.load_module` method was replaced by :meth:"

"`~importlib.abc.Loader.exec_module` and the import machinery assumed all the "

"boilerplate responsibilities of loading."

msgstr ""

"Η μέθοδος :meth:`~importlib.abc.Loader.load_module` αντικαταστάθηκε από την :"

"meth:`~importlib.abc.Loader.exec_module` και ο μηχανισμός εισαγωγής ανέλαβε "

"όλες τις τυποποιημένες ευθύνες της φόρτωσης."

#: reference/import.rst:450

msgid ""

"For compatibility with existing loaders, the import machinery will use the "

"``load_module()`` method of loaders if it exists and the loader does not "

"also implement ``exec_module()``. However, ``load_module()`` has been "

"deprecated and loaders should implement ``exec_module()`` instead."

msgstr ""

"Για συμβατότητα με υπάρχοντες loaders, ο μηχανισμός εισαγωγής θα "

"χρησιμοποιήσει τη μέθοδο ``load_module()`` αν υπάρχει και ο loader δεν "

"υλοποιεί την ``exec_module()``. Ωστόσο, η ``load_module()`` είναι "

"απαρχαιωμένη και οι loaders θα πρέπει να υλοποιούν την ``exec_module()``."

#: reference/import.rst:455

msgid ""

"The ``load_module()`` method must implement all the boilerplate loading "

"functionality described above in addition to executing the module. All the "

"same constraints apply, with some additional clarification:"

msgstr ""

"Η μέθοδος ``load_module()`` πρέπει να υλοποιεί όλη την τυποποιημένη "

"λειτουργικότητα φόρτωσης που περιγράφεται παραπάνω, επιπλέον της εκτέλεσης "

"του module. Ισχύουν οι ίδιοι περιορισμοί, με κάποιες επιπλέον διευκρινίσεις:"

#: reference/import.rst:459

msgid ""

"If there is an existing module object with the given name in :data:`sys."

"modules`, the loader must use that existing module. (Otherwise, :func:"

"`importlib.reload` will not work correctly.) If the named module does not "

"exist in :data:`sys.modules`, the loader must create a new module object and "

"add it to :data:`sys.modules`."

msgstr ""

"Αν υπάρχει ήδη αντικείμενο module με το συγκεκριμένο όνομα στο :data:`sys."

"modules`, ο loader πρέπει να χρησιμοποιήσει αυτό το υπάρχον module. "

"(Διαφορετικά, η :func:`importlib.reload` δεν θα λειτουργεί σωστά.) Αν το "

"module με το συγκεκριμένο όνομα δεν υπάρχει στο :data:`sys.modules`, ο "

"loader πρέπει να δημιουργήσει νέο αντικείμενο module και να το προσθέσει "

"στο :data:`sys.modules`."

#: reference/import.rst:465

msgid ""

"The module *must* exist in :data:`sys.modules` before the loader executes "

"the module code, to prevent unbounded recursion or multiple loading."

msgstr ""

"Το module *πρέπει* να υπάρχει στο :data:`sys.modules` πριν ο loader "

"εκτελέσει τον κώδικα του module, ώστε να αποτραπεί ατέρμονη αναδρομή ή "

"πολλαπλή φόρτωση."

#: reference/import.rst:469

msgid ""

"If loading fails, the loader must remove any modules it has inserted into :"

"data:`sys.modules`, but it must remove **only** the failing module(s), and "

"only if the loader itself has loaded the module(s) explicitly."

msgstr ""

"Αν η φόρτωση αποτύχει, ο loader πρέπει να αφαιρέσει οποιαδήποτε modules έχει "

"εισάγει στο :data:`sys.modules`, αλλά πρέπει να αφαιρέσει **μόνο** το/τα "

"module(s) που απέτυχαν, και μόνο αν ο loader έχει φορτώσει τα module(s) αυτά "

"ρητά."

#: reference/import.rst:474

msgid ""

"A :exc:`DeprecationWarning` is raised when ``exec_module()`` is defined but "

"``create_module()`` is not."

msgstr ""

"Γίνεται raise η :exc:`DeprecationWarning` όταν ορίζεται η ``exec_module()`` "

"αλλά δεν ορίζεται η ``create_module()``."

#: reference/import.rst:478

msgid ""

"An :exc:`ImportError` is raised when ``exec_module()`` is defined but "

"``create_module()`` is not."

msgstr ""

"Γίνεται raise το :exc:`ImportError` όταν ορίζεται η ``exec_module()`` αλλά "

"δεν ορίζεται η ``create_module()``."

#: reference/import.rst:482

msgid "Use of ``load_module()`` will raise :exc:`ImportWarning`."