OpenQuizz
Une application de gestion des contenus pédagogiques
pkg_resources Namespace Reference

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)
 

Variables

 FileExistsError
 
 WRITE_SUPPORT
 
 importlib_machinery
 
 require
 
 working_set
 
 add_activation_listener
 
 resources_stream
 
 cleanup_resources
 
 resource_dir
 
 resource_stream
 
 set_extraction_path
 
 resource_isdir
 
 resource_string
 
 iter_entry_points
 
 resource_listdir
 
 resource_filename
 
 resource_exists
 
 PY_MAJOR
 
 EGG_DIST
 
 BINARY_DIST
 
 SOURCE_DIST
 
 CHECKOUT_DIST
 
 DEVELOP_DIST
 
 macosVersionString
 
 darwinVersionString
 
 get_platform
 
 run_main
 
 AvailableDistributions
 
 empty_provider
 
 MODULE
 
 EGG_NAME
 

Detailed Description

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.

Function Documentation

◆ __getstate__()

def pkg_resources.__getstate__ ( )

◆ __setstate__()

def pkg_resources.__setstate__ (   state)

◆ compatible_platforms()

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.

◆ declare_namespace()

def pkg_resources.declare_namespace (   packageName)
Declare that package 'packageName' is a namespace package

◆ dist_factory()

def pkg_resources.dist_factory (   path_item,
  entry,
  only 
)
Return a dist_factory for the given entry.

◆ distributions_from_metadata()

def pkg_resources.distributions_from_metadata (   path)

◆ ensure_directory()

def pkg_resources.ensure_directory (   path)
Ensure that the parent directory of `path` exists

◆ evaluate_marker()

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.

◆ file_ns_handler()

def pkg_resources.file_ns_handler (   importer,
  path_item,
  packageName,
  module 
)
Compute an ns-package subpath for a filesystem or zipfile importer

◆ find_distributions()

def pkg_resources.find_distributions (   path_item,
  only = False 
)
Yield distributions accessible via `path_item`

◆ find_eggs_in_zip()

def pkg_resources.find_eggs_in_zip (   importer,
  path_item,
  only = False 
)
Find eggs in zip files; possibly multiple nested eggs.

◆ find_nothing()

def pkg_resources.find_nothing (   importer,
  path_item,
  only = False 
)

◆ find_on_path()

def pkg_resources.find_on_path (   importer,
  path_item,
  only = False 
)
Yield distributions accessible on a sys.path directory

◆ fixup_namespace_packages()

def pkg_resources.fixup_namespace_packages (   path_item,
  parent = None 
)
Ensure that previously-declared namespace packages include path_item

◆ get_build_platform()

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.

◆ get_default_cache()

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".

◆ get_distribution()

def pkg_resources.get_distribution (   dist)
Return a current distribution object for a Requirement or string

◆ get_entry_info()

def pkg_resources.get_entry_info (   dist,
  group,
  name 
)
Return the EntryPoint object for `group`+`name`, or ``None``

◆ get_entry_map()

def pkg_resources.get_entry_map (   dist,
  group = None 
)
Return the entry point map for `group`, or the full entry map

◆ get_provider()

def pkg_resources.get_provider (   moduleOrReq)
Return an IResourceProvider for the named module or requirement

◆ get_supported_platform()

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.

◆ invalid_marker()

def pkg_resources.invalid_marker (   text)
Validate text as a PEP 508 environment marker; return an exception
if invalid or False otherwise.

◆ issue_warning()

def pkg_resources.issue_warning ( args,
**  kw 
)

◆ load_entry_point()

def pkg_resources.load_entry_point (   dist,
  group,
  name 
)
Return `name` entry point of `group` for `dist` or raise ImportError

◆ non_empty_lines()

def pkg_resources.non_empty_lines (   path)
Yield non-empty lines from file at path

◆ normalize_path()

def pkg_resources.normalize_path (   filename)
Normalize a file/dir name for comparison purposes

◆ null_ns_handler()

def pkg_resources.null_ns_handler (   importer,
  path_item,
  packageName,
  module 
)

◆ parse_requirements()

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.

◆ parse_version()

def pkg_resources.parse_version (   v)

◆ register_finder()

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.

◆ register_loader_type()

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.

◆ register_namespace_handler()

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``.

◆ resolve_egg_link()

def pkg_resources.resolve_egg_link (   path)
Given a path to an .egg-link, resolve distributions
present in the referenced path.

◆ run_script()

def pkg_resources.run_script (   dist_spec,
  script_name 
)
Locate distribution `dist_spec` and run its `script_name` script

◆ safe_extra()

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.

◆ safe_listdir()

def pkg_resources.safe_listdir (   path)
Attempt to list contents of path, but suppress some exceptions.

◆ safe_name()

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 '-'.

◆ safe_version()

def pkg_resources.safe_version (   version)
Convert an arbitrary string to a standard version string

◆ split_sections()

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``.

◆ to_filename()

def pkg_resources.to_filename (   name)
Convert a project or version name to its filename-escaped form

Any '-' characters are currently replaced with '_'.

◆ yield_lines()

def pkg_resources.yield_lines (   strs)
Yield non-empty/non-comment lines of a string or sequence

Variable Documentation

◆ add_activation_listener

add_activation_listener

◆ AvailableDistributions

AvailableDistributions

◆ BINARY_DIST

BINARY_DIST

◆ CHECKOUT_DIST

CHECKOUT_DIST

◆ cleanup_resources

cleanup_resources

◆ darwinVersionString

darwinVersionString

◆ DEVELOP_DIST

DEVELOP_DIST

◆ EGG_DIST

EGG_DIST

◆ EGG_NAME

EGG_NAME

◆ empty_provider

empty_provider

◆ FileExistsError

FileExistsError

◆ get_platform

get_platform

◆ importlib_machinery

importlib_machinery

◆ iter_entry_points

iter_entry_points

◆ macosVersionString

macosVersionString

◆ MODULE

MODULE

◆ PY_MAJOR

PY_MAJOR

◆ require

require

◆ resource_dir

resource_dir

◆ resource_exists

resource_exists

◆ resource_filename

resource_filename

◆ resource_isdir

resource_isdir

◆ resource_listdir

resource_listdir

◆ resource_stream

resource_stream

◆ resource_string

resource_string

◆ resources_stream

resources_stream

◆ run_main

run_main

◆ set_extraction_path

set_extraction_path

◆ SOURCE_DIST

SOURCE_DIST

◆ working_set

working_set

◆ WRITE_SUPPORT

WRITE_SUPPORT