cpython/Lib/importlib/abc.py at 3.5 · python/cpython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

"""Abstract base classes related to import."""

from . import _bootstrap

from . import _bootstrap_external

from . import machinery

try:

import _frozen_importlib

except ImportError as exc:

if exc.name != '_frozen_importlib':

raise

_frozen_importlib = None

try:

import _frozen_importlib_external

except ImportError as exc:

_frozen_importlib_external = _bootstrap_external

import abc

def _register(abstract_cls, *classes):

for cls in classes:

abstract_cls.register(cls)

if _frozen_importlib is not None:

try:

frozen_cls = getattr(_frozen_importlib, cls.__name__)

except AttributeError:

frozen_cls = getattr(_frozen_importlib_external, cls.__name__)

abstract_cls.register(frozen_cls)

class Finder(metaclass=abc.ABCMeta):

"""Legacy abstract base class for import finders.

It may be subclassed for compatibility with legacy third party

reimplementations of the import system. Otherwise, finder

implementations should derive from the more specific MetaPathFinder

or PathEntryFinder ABCs.

"""

@abc.abstractmethod

def find_module(self, fullname, path=None):

"""An abstract method that should find a module.

The fullname is a str and the optional path is a str or None.

Returns a Loader object or None.

"""

class MetaPathFinder(Finder):

"""Abstract base class for import finders on sys.meta_path."""

# We don't define find_spec() here since that would break

# hasattr checks we do to support backward compatibility.

def find_module(self, fullname, path):

"""Return a loader for the module.

If no module is found, return None. The fullname is a str and

the path is a list of strings or None.

This method is deprecated in favor of finder.find_spec(). If find_spec()

exists then backwards-compatible functionality is provided for this

method.

"""

if not hasattr(self, 'find_spec'):

return None

found = self.find_spec(fullname, path)

return found.loader if found is not None else None

def invalidate_caches(self):

"""An optional method for clearing the finder's cache, if any.

This method is used by importlib.invalidate_caches().

"""

_register(MetaPathFinder, machinery.BuiltinImporter, machinery.FrozenImporter,

machinery.PathFinder, machinery.WindowsRegistryFinder)

class PathEntryFinder(Finder):

"""Abstract base class for path entry finders used by PathFinder."""

# We don't define find_spec() here since that would break

# hasattr checks we do to support backward compatibility.

def find_loader(self, fullname):

"""Return (loader, namespace portion) for the path entry.

The fullname is a str. The namespace portion is a sequence of

path entries contributing to part of a namespace package. The

sequence may be empty. If loader is not None, the portion will

be ignored.

The portion will be discarded if another path entry finder

locates the module as a normal module or package.

This method is deprecated in favor of finder.find_spec(). If find_spec()

is provided than backwards-compatible functionality is provided.

"""

if not hasattr(self, 'find_spec'):

return None, []

found = self.find_spec(fullname)

if found is not None:

if not found.submodule_search_locations:

portions = []

else:

portions = found.submodule_search_locations

return found.loader, portions

else:

return None, []

find_module = _bootstrap_external._find_module_shim

def invalidate_caches(self):

"""An optional method for clearing the finder's cache, if any.

This method is used by PathFinder.invalidate_caches().

"""

_register(PathEntryFinder, machinery.FileFinder)

class Loader(metaclass=abc.ABCMeta):

"""Abstract base class for import loaders."""

def create_module(self, spec):

"""Return a module to initialize and into which to load.

This method should raise ImportError if anything prevents it

from creating a new module. It may return None to indicate

that the spec should create the new module.

"""

# By default, defer to default semantics for the new module.

return None

# We don't define exec_module() here since that would break

# hasattr checks we do to support backward compatibility.

def load_module(self, fullname):

"""Return the loaded module.

The module must be added to sys.modules and have import-related

attributes set properly. The fullname is a str.

ImportError is raised on failure.

This method is deprecated in favor of loader.exec_module(). If

exec_module() exists then it is used to provide a backwards-compatible

functionality for this method.

"""

if not hasattr(self, 'exec_module'):

raise ImportError

return _bootstrap._load_module_shim(self, fullname)

def module_repr(self, module):

"""Return a module's repr.

Used by the module type when the method does not raise

NotImplementedError.

This method is deprecated.

"""

# The exception will cause ModuleType.__repr__ to ignore this method.

raise NotImplementedError

class ResourceLoader(Loader):

"""Abstract base class for loaders which can return data from their

back-end storage.

This ABC represents one of the optional protocols specified by PEP 302.

"""

@abc.abstractmethod

def get_data(self, path):

"""Abstract method which when implemented should return the bytes for

the specified path. The path must be a str."""

raise IOError

class InspectLoader(Loader):

"""Abstract base class for loaders which support inspection about the

modules they can load.

This ABC represents one of the optional protocols specified by PEP 302.

"""

def is_package(self, fullname):

"""Optional method which when implemented should return whether the

module is a package. The fullname is a str. Returns a bool.

Raises ImportError if the module cannot be found.

"""

raise ImportError

def get_code(self, fullname):

"""Method which returns the code object for the module.

The fullname is a str. Returns a types.CodeType if possible, else

returns None if a code object does not make sense

(e.g. built-in module). Raises ImportError if the module cannot be

found.

"""

source = self.get_source(fullname)

if source is None:

return None

return self.source_to_code(source)

@abc.abstractmethod

def get_source(self, fullname):

"""Abstract method which should return the source code for the

module. The fullname is a str. Returns a str.

Raises ImportError if the module cannot be found.

"""

raise ImportError

@staticmethod

def source_to_code(data, path='<string>'):

"""Compile 'data' into a code object.

The 'data' argument can be anything that compile() can handle. The'path'

argument should be where the data was retrieved (when applicable)."""

return compile(data, path, 'exec', dont_inherit=True)

exec_module = _bootstrap_external._LoaderBasics.exec_module

load_module = _bootstrap_external._LoaderBasics.load_module

_register(InspectLoader, machinery.BuiltinImporter, machinery.FrozenImporter)

class ExecutionLoader(InspectLoader):

"""Abstract base class for loaders that wish to support the execution of

modules as scripts.

This ABC represents one of the optional protocols specified in PEP 302.

"""

@abc.abstractmethod

def get_filename(self, fullname):

"""Abstract method which should return the value that __file__ is to be

set to.

Raises ImportError if the module cannot be found.

"""

raise ImportError

def get_code(self, fullname):

"""Method to return the code object for fullname.

Should return None if not applicable (e.g. built-in module).

Raise ImportError if the module cannot be found.

"""

source = self.get_source(fullname)

if source is None:

return None

try:

path = self.get_filename(fullname)

except ImportError:

return self.source_to_code(source)

else:

return self.source_to_code(source, path)

_register(ExecutionLoader, machinery.ExtensionFileLoader)

class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader):

"""Abstract base class partially implementing the ResourceLoader and

ExecutionLoader ABCs."""

_register(FileLoader, machinery.SourceFileLoader,

machinery.SourcelessFileLoader)

class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLoader):

"""Abstract base class for loading source code (and optionally any

corresponding bytecode).

To support loading from source code, the abstractmethods inherited from

ResourceLoader and ExecutionLoader need to be implemented. To also support

loading from bytecode, the optional methods specified directly by this ABC

is required.

Inherited abstractmethods not implemented in this ABC:

* ResourceLoader.get_data

* ExecutionLoader.get_filename

"""

def path_mtime(self, path):

"""Return the (int) modification time for the path (str)."""

if self.path_stats.__func__ is SourceLoader.path_stats:

raise IOError

return int(self.path_stats(path)['mtime'])

def path_stats(self, path):

"""Return a metadata dict for the source pointed to by the path (str).

Possible keys:

- 'mtime' (mandatory) is the numeric timestamp of last source

code modification;

- 'size' (optional) is the size in bytes of the source code.

"""

if self.path_mtime.__func__ is SourceLoader.path_mtime:

raise IOError

return {'mtime': self.path_mtime(path)}

def set_data(self, path, data):

"""Write the bytes to the path (if possible).

Accepts a str path and data as bytes.

Any needed intermediary directories are to be created. If for some

reason the file cannot be written because of permissions, fail

silently.

"""

_register(SourceLoader, machinery.SourceFileLoader)

cpython/Lib/importlib/abc.py at 3.5 · python/cpython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

abc.py

Latest commit

History

Breadcrumbs

abc.py

File metadata and controls