OpenQuizz
Une application de gestion des contenus pédagogiques
|
Namespaces | |
_vendor | |
extern | |
Data Structures | |
class | _ReqExtras |
class | ContextualVersionConflict |
class | DefaultProvider |
class | DistInfoDistribution |
class | Distribution |
class | DistributionNotFound |
class | EggInfoDistribution |
class | EggMetadata |
class | EggProvider |
class | EmptyProvider |
class | EntryPoint |
class | Environment |
class | ExtractionError |
class | FileMetadata |
class | IMetadataProvider |
class | IResourceProvider |
class | MemoizedZipManifests |
class | NoDists |
class | NullProvider |
class | PathMetadata |
class | PEP440Warning |
class | PkgResourcesDeprecationWarning |
class | Requirement |
class | RequirementParseError |
class | ResolutionError |
class | ResourceManager |
class | UnknownExtra |
class | VersionConflict |
class | WorkingSet |
class | ZipManifests |
class | ZipProvider |
Functions | |
def | parse_version (v) |
def | __getstate__ () |
def | __setstate__ (state) |
def | get_supported_platform () |
def | register_loader_type (loader_type, provider_factory) |
def | get_provider (moduleOrReq) |
def | get_build_platform () |
def | compatible_platforms (provided, required) |
def | run_script (dist_spec, script_name) |
def | get_distribution (dist) |
def | load_entry_point (dist, group, name) |
def | get_entry_map (dist, group=None) |
def | get_entry_info (dist, group, name) |
def | get_default_cache () |
def | safe_name (name) |
def | safe_version (version) |
def | safe_extra (extra) |
def | to_filename (name) |
def | invalid_marker (text) |
def | evaluate_marker (text, extra=None) |
def | register_finder (importer_type, distribution_finder) |
def | find_distributions (path_item, only=False) |
def | find_eggs_in_zip (importer, path_item, only=False) |
def | find_nothing (importer, path_item, only=False) |
def | find_on_path (importer, path_item, only=False) |
def | dist_factory (path_item, entry, only) |
def | safe_listdir (path) |
def | distributions_from_metadata (path) |
def | non_empty_lines (path) |
def | resolve_egg_link (path) |
def | register_namespace_handler (importer_type, namespace_handler) |
def | declare_namespace (packageName) |
def | fixup_namespace_packages (path_item, parent=None) |
def | file_ns_handler (importer, path_item, packageName, module) |
def | null_ns_handler (importer, path_item, packageName, module) |
def | normalize_path (filename) |
def | yield_lines (strs) |
def | issue_warning (*args, **kw) |
def | parse_requirements (strs) |
def | ensure_directory (path) |
def | split_sections (s) |
Package resource API -------------------- A resource is a logical file contained within a package, or a logical subdirectory thereof. The package resource API expects resource names to have their path parts separated with ``/``, *not* whatever the local path separator is. Do not use os.path operations to manipulate resource names being passed into the API. The package resource API is designed to work with normal filesystem packages, .egg files, and unpacked .egg files. It can also work in a limited way with .zip files and with custom PEP 302 loaders that support the ``get_data()`` method.
def pkg_resources.__getstate__ | ( | ) |
def pkg_resources.__setstate__ | ( | state | ) |
def pkg_resources.compatible_platforms | ( | provided, | |
required | |||
) |
Can code for the `provided` platform run on the `required` platform? Returns true if either platform is ``None``, or the platforms are equal. XXX Needs compatibility checks for Linux and other unixy OSes.
def pkg_resources.declare_namespace | ( | packageName | ) |
Declare that package 'packageName' is a namespace package
def pkg_resources.dist_factory | ( | path_item, | |
entry, | |||
only | |||
) |
Return a dist_factory for the given entry.
def pkg_resources.distributions_from_metadata | ( | path | ) |
def pkg_resources.ensure_directory | ( | path | ) |
Ensure that the parent directory of `path` exists
def pkg_resources.evaluate_marker | ( | text, | |
extra = None |
|||
) |
Evaluate a PEP 508 environment marker. Return a boolean indicating the marker result in this environment. Raise SyntaxError if marker is invalid. This implementation uses the 'pyparsing' module.
def pkg_resources.file_ns_handler | ( | importer, | |
path_item, | |||
packageName, | |||
module | |||
) |
Compute an ns-package subpath for a filesystem or zipfile importer
def pkg_resources.find_distributions | ( | path_item, | |
only = False |
|||
) |
Yield distributions accessible via `path_item`
def pkg_resources.find_eggs_in_zip | ( | importer, | |
path_item, | |||
only = False |
|||
) |
Find eggs in zip files; possibly multiple nested eggs.
def pkg_resources.find_nothing | ( | importer, | |
path_item, | |||
only = False |
|||
) |
def pkg_resources.find_on_path | ( | importer, | |
path_item, | |||
only = False |
|||
) |
Yield distributions accessible on a sys.path directory
def pkg_resources.fixup_namespace_packages | ( | path_item, | |
parent = None |
|||
) |
Ensure that previously-declared namespace packages include path_item
def pkg_resources.get_build_platform | ( | ) |
Return this platform's string for platform-specific distributions XXX Currently this is the same as ``distutils.util.get_platform()``, but it needs some hacks for Linux and macOS.
def pkg_resources.get_default_cache | ( | ) |
Return the ``PYTHON_EGG_CACHE`` environment variable or a platform-relevant user cache dir for an app named "Python-Eggs".
def pkg_resources.get_distribution | ( | dist | ) |
Return a current distribution object for a Requirement or string
def pkg_resources.get_entry_info | ( | dist, | |
group, | |||
name | |||
) |
Return the EntryPoint object for `group`+`name`, or ``None``
def pkg_resources.get_entry_map | ( | dist, | |
group = None |
|||
) |
Return the entry point map for `group`, or the full entry map
def pkg_resources.get_provider | ( | moduleOrReq | ) |
Return an IResourceProvider for the named module or requirement
def pkg_resources.get_supported_platform | ( | ) |
Return this platform's maximum compatible version. distutils.util.get_platform() normally reports the minimum version of macOS that would be required to *use* extensions produced by distutils. But what we want when checking compatibility is to know the version of macOS that we are *running*. To allow usage of packages that explicitly require a newer version of macOS, we must also know the current version of the OS. If this condition occurs for any other platform with a version in its platform strings, this function should be extended accordingly.
def pkg_resources.invalid_marker | ( | text | ) |
Validate text as a PEP 508 environment marker; return an exception if invalid or False otherwise.
def pkg_resources.issue_warning | ( | * | args, |
** | kw | ||
) |
def pkg_resources.load_entry_point | ( | dist, | |
group, | |||
name | |||
) |
Return `name` entry point of `group` for `dist` or raise ImportError
def pkg_resources.non_empty_lines | ( | path | ) |
Yield non-empty lines from file at path
def pkg_resources.normalize_path | ( | filename | ) |
Normalize a file/dir name for comparison purposes
def pkg_resources.null_ns_handler | ( | importer, | |
path_item, | |||
packageName, | |||
module | |||
) |
def pkg_resources.parse_requirements | ( | strs | ) |
Yield ``Requirement`` objects for each specification in `strs` `strs` must be a string, or a (possibly-nested) iterable thereof.
def pkg_resources.parse_version | ( | v | ) |
def pkg_resources.register_finder | ( | importer_type, | |
distribution_finder | |||
) |
Register `distribution_finder` to find distributions in sys.path items `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `distribution_finder` is a callable that, passed a path item and the importer instance, yields ``Distribution`` instances found on that path item. See ``pkg_resources.find_on_path`` for an example.
def pkg_resources.register_loader_type | ( | loader_type, | |
provider_factory | |||
) |
Register `provider_factory` to make providers for `loader_type` `loader_type` is the type or class of a PEP 302 ``module.__loader__``, and `provider_factory` is a function that, passed a *module* object, returns an ``IResourceProvider`` for that module.
def pkg_resources.register_namespace_handler | ( | importer_type, | |
namespace_handler | |||
) |
Register `namespace_handler` to declare namespace packages `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `namespace_handler` is a callable like this:: def namespace_handler(importer, path_entry, moduleName, module): # return a path_entry to use for child packages Namespace handlers are only called if the importer object has already agreed that it can handle the relevant path item, and they should only return a subpath if the module __path__ does not already contain an equivalent subpath. For an example namespace handler, see ``pkg_resources.file_ns_handler``.
def pkg_resources.resolve_egg_link | ( | path | ) |
Given a path to an .egg-link, resolve distributions present in the referenced path.
def pkg_resources.run_script | ( | dist_spec, | |
script_name | |||
) |
Locate distribution `dist_spec` and run its `script_name` script
def pkg_resources.safe_extra | ( | extra | ) |
Convert an arbitrary string to a standard 'extra' name Any runs of non-alphanumeric characters are replaced with a single '_', and the result is always lowercased.
def pkg_resources.safe_listdir | ( | path | ) |
Attempt to list contents of path, but suppress some exceptions.
def pkg_resources.safe_name | ( | name | ) |
Convert an arbitrary string to a standard distribution name Any runs of non-alphanumeric/. characters are replaced with a single '-'.
def pkg_resources.safe_version | ( | version | ) |
Convert an arbitrary string to a standard version string
def pkg_resources.split_sections | ( | s | ) |
Split a string or iterable thereof into (section, content) pairs Each ``section`` is a stripped version of the section header ("[section]") and each ``content`` is a list of stripped lines excluding blank lines and comment-only lines. If there are any such lines before the first section header, they're returned in a first ``section`` of ``None``.
def pkg_resources.to_filename | ( | name | ) |
Convert a project or version name to its filename-escaped form Any '-' characters are currently replaced with '_'.
def pkg_resources.yield_lines | ( | strs | ) |
Yield non-empty/non-comment lines of a string or sequence
add_activation_listener |
AvailableDistributions |
BINARY_DIST |
CHECKOUT_DIST |
cleanup_resources |
darwinVersionString |
DEVELOP_DIST |
EGG_DIST |
EGG_NAME |
empty_provider |
FileExistsError |
get_platform |
importlib_machinery |
iter_entry_points |
macosVersionString |
MODULE |
PY_MAJOR |
require |
resource_dir |
resource_exists |
resource_filename |
resource_isdir |
resource_listdir |
resource_stream |
resource_string |
resources_stream |
run_main |
set_extraction_path |
SOURCE_DIST |
working_set |
WRITE_SUPPORT |