Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

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

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

# -*- coding: utf-8 -*- 

 

""" 

requests.session 

~~~~~~~~~~~~~~~~ 

 

This module provides a Session object to manage and persist settings across 

requests (cookies, auth, proxies). 

 

""" 

import os 

from collections import Mapping 

from datetime import datetime 

 

from .auth import _basic_auth_str 

from .compat import cookielib, OrderedDict, urljoin, urlparse 

from .cookies import ( 

    cookiejar_from_dict, extract_cookies_to_jar, RequestsCookieJar, merge_cookies) 

from .models import Request, PreparedRequest, DEFAULT_REDIRECT_LIMIT 

from .hooks import default_hooks, dispatch_hook 

from .utils import to_key_val_list, default_headers, to_native_string 

from .exceptions import ( 

    TooManyRedirects, InvalidSchema, ChunkedEncodingError, ContentDecodingError) 

from .packages.urllib3._collections import RecentlyUsedContainer 

from .structures import CaseInsensitiveDict 

 

from .adapters import HTTPAdapter 

 

from .utils import ( 

    requote_uri, get_environ_proxies, get_netrc_auth, should_bypass_proxies, 

    get_auth_from_url 

) 

 

from .status_codes import codes 

 

# formerly defined here, reexposed here for backward compatibility 

from .models import REDIRECT_STATI 

 

REDIRECT_CACHE_SIZE = 1000 

 

 

def merge_setting(request_setting, session_setting, dict_class=OrderedDict): 

    """ 

    Determines appropriate setting for a given request, taking into account the 

    explicit setting on that request, and the setting in the session. If a 

    setting is a dictionary, they will be merged together using `dict_class` 

    """ 

 

    if session_setting is None: 

        return request_setting 

 

    if request_setting is None: 

        return session_setting 

 

    # Bypass if not a dictionary (e.g. verify) 

    if not ( 

            isinstance(session_setting, Mapping) and 

            isinstance(request_setting, Mapping) 

    ): 

        return request_setting 

 

    merged_setting = dict_class(to_key_val_list(session_setting)) 

    merged_setting.update(to_key_val_list(request_setting)) 

 

    # Remove keys that are set to None. 

    for (k, v) in request_setting.items(): 

        if v is None: 

            del merged_setting[k] 

 

    merged_setting = dict((k, v) for (k, v) in merged_setting.items() if v is not None) 

 

    return merged_setting 

 

 

def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict): 

    """ 

    Properly merges both requests and session hooks. 

 

    This is necessary because when request_hooks == {'response': []}, the 

    merge breaks Session hooks entirely. 

    """ 

    if session_hooks is None or session_hooks.get('response') == []: 

        return request_hooks 

 

    if request_hooks is None or request_hooks.get('response') == []: 

        return session_hooks 

 

    return merge_setting(request_hooks, session_hooks, dict_class) 

 

 

class SessionRedirectMixin(object): 

    def resolve_redirects(self, resp, req, stream=False, timeout=None, 

                          verify=True, cert=None, proxies=None, **adapter_kwargs): 

        """Receives a Response. Returns a generator of Responses.""" 

 

        i = 0 

        hist = [] # keep track of history 

 

        while resp.is_redirect: 

            prepared_request = req.copy() 

 

            if i > 0: 

                # Update history and keep track of redirects. 

                hist.append(resp) 

                new_hist = list(hist) 

                resp.history = new_hist 

 

            try: 

                resp.content  # Consume socket so it can be released 

            except (ChunkedEncodingError, ContentDecodingError, RuntimeError): 

                resp.raw.read(decode_content=False) 

 

            if i >= self.max_redirects: 

                raise TooManyRedirects('Exceeded %s redirects.' % self.max_redirects) 

 

            # Release the connection back into the pool. 

            resp.close() 

 

            url = resp.headers['location'] 

            method = req.method 

 

            # Handle redirection without scheme (see: RFC 1808 Section 4) 

            if url.startswith('//'): 

                parsed_rurl = urlparse(resp.url) 

                url = '%s:%s' % (parsed_rurl.scheme, url) 

 

            # The scheme should be lower case... 

            parsed = urlparse(url) 

            url = parsed.geturl() 

 

            # Facilitate relative 'location' headers, as allowed by RFC 7231. 

            # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource') 

            # Compliant with RFC3986, we percent encode the url. 

            if not parsed.netloc: 

                url = urljoin(resp.url, requote_uri(url)) 

            else: 

                url = requote_uri(url) 

 

            prepared_request.url = to_native_string(url) 

            # Cache the url, unless it redirects to itself. 

            if resp.is_permanent_redirect and req.url != prepared_request.url: 

                self.redirect_cache[req.url] = prepared_request.url 

 

            # http://tools.ietf.org/html/rfc7231#section-6.4.4 

            if (resp.status_code == codes.see_other and 

                    method != 'HEAD'): 

                method = 'GET' 

 

            # Do what the browsers do, despite standards... 

            # First, turn 302s into GETs. 

            if resp.status_code == codes.found and method != 'HEAD': 

                method = 'GET' 

 

            # Second, if a POST is responded to with a 301, turn it into a GET. 

            # This bizarre behaviour is explained in Issue 1704. 

            if resp.status_code == codes.moved and method == 'POST': 

                method = 'GET' 

 

            prepared_request.method = method 

 

            # https://github.com/kennethreitz/requests/issues/1084 

            if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect): 

                if 'Content-Length' in prepared_request.headers: 

                    del prepared_request.headers['Content-Length'] 

 

                prepared_request.body = None 

 

            headers = prepared_request.headers 

            try: 

                del headers['Cookie'] 

            except KeyError: 

                pass 

 

            # Extract any cookies sent on the response to the cookiejar 

            # in the new request. Because we've mutated our copied prepared 

            # request, use the old one that we haven't yet touched. 

            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw) 

            prepared_request._cookies.update(self.cookies) 

            prepared_request.prepare_cookies(prepared_request._cookies) 

 

            # Rebuild auth and proxy information. 

            proxies = self.rebuild_proxies(prepared_request, proxies) 

            self.rebuild_auth(prepared_request, resp) 

 

            # Override the original request. 

            req = prepared_request 

 

            resp = self.send( 

                req, 

                stream=stream, 

                timeout=timeout, 

                verify=verify, 

                cert=cert, 

                proxies=proxies, 

                allow_redirects=False, 

                **adapter_kwargs 

            ) 

 

            extract_cookies_to_jar(self.cookies, prepared_request, resp.raw) 

 

            i += 1 

            yield resp 

 

    def rebuild_auth(self, prepared_request, response): 

        """ 

        When being redirected we may want to strip authentication from the 

        request to avoid leaking credentials. This method intelligently removes 

        and reapplies authentication where possible to avoid credential loss. 

        """ 

        headers = prepared_request.headers 

        url = prepared_request.url 

 

        if 'Authorization' in headers: 

            # If we get redirected to a new host, we should strip out any 

            # authentication headers. 

            original_parsed = urlparse(response.request.url) 

            redirect_parsed = urlparse(url) 

 

            if (original_parsed.hostname != redirect_parsed.hostname): 

                del headers['Authorization'] 

 

        # .netrc might have more auth for us on our new host. 

        new_auth = get_netrc_auth(url) if self.trust_env else None 

        if new_auth is not None: 

            prepared_request.prepare_auth(new_auth) 

 

        return 

 

    def rebuild_proxies(self, prepared_request, proxies): 

        """ 

        This method re-evaluates the proxy configuration by considering the 

        environment variables. If we are redirected to a URL covered by 

        NO_PROXY, we strip the proxy configuration. Otherwise, we set missing 

        proxy keys for this URL (in case they were stripped by a previous 

        redirect). 

 

        This method also replaces the Proxy-Authorization header where 

        necessary. 

        """ 

        headers = prepared_request.headers 

        url = prepared_request.url 

        scheme = urlparse(url).scheme 

        new_proxies = proxies.copy() if proxies is not None else {} 

 

        if self.trust_env and not should_bypass_proxies(url): 

            environ_proxies = get_environ_proxies(url) 

 

            proxy = environ_proxies.get(scheme) 

 

            if proxy: 

                new_proxies.setdefault(scheme, environ_proxies[scheme]) 

 

        if 'Proxy-Authorization' in headers: 

            del headers['Proxy-Authorization'] 

 

        try: 

            username, password = get_auth_from_url(new_proxies[scheme]) 

        except KeyError: 

            username, password = None, None 

 

        if username and password: 

            headers['Proxy-Authorization'] = _basic_auth_str(username, password) 

 

        return new_proxies 

 

 

class Session(SessionRedirectMixin): 

    """A Requests session. 

 

    Provides cookie persistence, connection-pooling, and configuration. 

 

    Basic Usage:: 

 

      >>> import requests 

      >>> s = requests.Session() 

      >>> s.get('http://httpbin.org/get') 

      200 

    """ 

 

    __attrs__ = [ 

        'headers', 'cookies', 'auth', 'proxies', 'hooks', 'params', 'verify', 

        'cert', 'prefetch', 'adapters', 'stream', 'trust_env', 

        'max_redirects', 

    ] 

 

    def __init__(self): 

 

        #: A case-insensitive dictionary of headers to be sent on each 

        #: :class:`Request <Request>` sent from this 

        #: :class:`Session <Session>`. 

        self.headers = default_headers() 

 

        #: Default Authentication tuple or object to attach to 

        #: :class:`Request <Request>`. 

        self.auth = None 

 

        #: Dictionary mapping protocol to the URL of the proxy (e.g. 

        #: {'http': 'foo.bar:3128'}) to be used on each 

        #: :class:`Request <Request>`. 

        self.proxies = {} 

 

        #: Event-handling hooks. 

        self.hooks = default_hooks() 

 

        #: Dictionary of querystring data to attach to each 

        #: :class:`Request <Request>`. The dictionary values may be lists for 

        #: representing multivalued query parameters. 

        self.params = {} 

 

        #: Stream response content default. 

        self.stream = False 

 

        #: SSL Verification default. 

        self.verify = True 

 

        #: SSL certificate default. 

        self.cert = None 

 

        #: Maximum number of redirects allowed. If the request exceeds this 

        #: limit, a :class:`TooManyRedirects` exception is raised. 

        self.max_redirects = DEFAULT_REDIRECT_LIMIT 

 

        #: Should we trust the environment? 

        self.trust_env = True 

 

        #: A CookieJar containing all currently outstanding cookies set on this 

        #: session. By default it is a 

        #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but 

        #: may be any other ``cookielib.CookieJar`` compatible object. 

        self.cookies = cookiejar_from_dict({}) 

 

        # Default connection adapters. 

        self.adapters = OrderedDict() 

        self.mount('https://', HTTPAdapter()) 

        self.mount('http://', HTTPAdapter()) 

 

        # Only store 1000 redirects to prevent using infinite memory 

        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE) 

 

    def __enter__(self): 

        return self 

 

    def __exit__(self, *args): 

        self.close() 

 

    def prepare_request(self, request): 

        """Constructs a :class:`PreparedRequest <PreparedRequest>` for 

        transmission and returns it. The :class:`PreparedRequest` has settings 

        merged from the :class:`Request <Request>` instance and those of the 

        :class:`Session`. 

 

        :param request: :class:`Request` instance to prepare with this 

            session's settings. 

        """ 

        cookies = request.cookies or {} 

 

        # Bootstrap CookieJar. 

        if not isinstance(cookies, cookielib.CookieJar): 

            cookies = cookiejar_from_dict(cookies) 

 

        # Merge with session cookies 

        merged_cookies = merge_cookies( 

            merge_cookies(RequestsCookieJar(), self.cookies), cookies) 

 

 

        # Set environment's basic authentication if not explicitly set. 

        auth = request.auth 

        if self.trust_env and not auth and not self.auth: 

            auth = get_netrc_auth(request.url) 

 

        p = PreparedRequest() 

        p.prepare( 

            method=request.method.upper(), 

            url=request.url, 

            files=request.files, 

            data=request.data, 

            json=request.json, 

            headers=merge_setting(request.headers, self.headers, dict_class=CaseInsensitiveDict), 

            params=merge_setting(request.params, self.params), 

            auth=merge_setting(auth, self.auth), 

            cookies=merged_cookies, 

            hooks=merge_hooks(request.hooks, self.hooks), 

        ) 

        return p 

 

    def request(self, method, url, 

        params=None, 

        data=None, 

        headers=None, 

        cookies=None, 

        files=None, 

        auth=None, 

        timeout=None, 

        allow_redirects=True, 

        proxies=None, 

        hooks=None, 

        stream=None, 

        verify=None, 

        cert=None, 

        json=None): 

        """Constructs a :class:`Request <Request>`, prepares it and sends it. 

        Returns :class:`Response <Response>` object. 

 

        :param method: method for the new :class:`Request` object. 

        :param url: URL for the new :class:`Request` object. 

        :param params: (optional) Dictionary or bytes to be sent in the query 

            string for the :class:`Request`. 

        :param data: (optional) Dictionary or bytes to send in the body of the 

            :class:`Request`. 

        :param json: (optional) json to send in the body of the 

            :class:`Request`. 

        :param headers: (optional) Dictionary of HTTP Headers to send with the 

            :class:`Request`. 

        :param cookies: (optional) Dict or CookieJar object to send with the 

            :class:`Request`. 

        :param files: (optional) Dictionary of ``'filename': file-like-objects`` 

            for multipart encoding upload. 

        :param auth: (optional) Auth tuple or callable to enable 

            Basic/Digest/Custom HTTP Auth. 

        :param timeout: (optional) How long to wait for the server to send 

            data before giving up, as a float, or a (`connect timeout, read 

            timeout <user/advanced.html#timeouts>`_) tuple. 

        :type timeout: float or tuple 

        :param allow_redirects: (optional) Set to True by default. 

        :type allow_redirects: bool 

        :param proxies: (optional) Dictionary mapping protocol to the URL of 

            the proxy. 

        :param stream: (optional) whether to immediately download the response 

            content. Defaults to ``False``. 

        :param verify: (optional) if ``True``, the SSL cert will be verified. 

            A CA_BUNDLE path can also be provided. 

        :param cert: (optional) if String, path to ssl client cert file (.pem). 

            If Tuple, ('cert', 'key') pair. 

        """ 

 

        method = to_native_string(method) 

 

        # Create the Request. 

        req = Request( 

            method = method.upper(), 

            url = url, 

            headers = headers, 

            files = files, 

            data = data or {}, 

            json = json, 

            params = params or {}, 

            auth = auth, 

            cookies = cookies, 

            hooks = hooks, 

        ) 

        prep = self.prepare_request(req) 

 

        proxies = proxies or {} 

 

        settings = self.merge_environment_settings( 

            prep.url, proxies, stream, verify, cert 

        ) 

 

        # Send the request. 

        send_kwargs = { 

            'timeout': timeout, 

            'allow_redirects': allow_redirects, 

        } 

        send_kwargs.update(settings) 

        resp = self.send(prep, **send_kwargs) 

 

        return resp 

 

    def get(self, url, **kwargs): 

        """Sends a GET request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        kwargs.setdefault('allow_redirects', True) 

        return self.request('GET', url, **kwargs) 

 

    def options(self, url, **kwargs): 

        """Sends a OPTIONS request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        kwargs.setdefault('allow_redirects', True) 

        return self.request('OPTIONS', url, **kwargs) 

 

    def head(self, url, **kwargs): 

        """Sends a HEAD request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        kwargs.setdefault('allow_redirects', False) 

        return self.request('HEAD', url, **kwargs) 

 

    def post(self, url, data=None, json=None, **kwargs): 

        """Sends a POST request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`. 

        :param json: (optional) json to send in the body of the :class:`Request`. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        return self.request('POST', url, data=data, json=json, **kwargs) 

 

    def put(self, url, data=None, **kwargs): 

        """Sends a PUT request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        return self.request('PUT', url, data=data, **kwargs) 

 

    def patch(self, url, data=None, **kwargs): 

        """Sends a PATCH request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        return self.request('PATCH', url,  data=data, **kwargs) 

 

    def delete(self, url, **kwargs): 

        """Sends a DELETE request. Returns :class:`Response` object. 

 

        :param url: URL for the new :class:`Request` object. 

        :param \*\*kwargs: Optional arguments that ``request`` takes. 

        """ 

 

        return self.request('DELETE', url, **kwargs) 

 

    def send(self, request, **kwargs): 

        """Send a given PreparedRequest.""" 

        # Set defaults that the hooks can utilize to ensure they always have 

        # the correct parameters to reproduce the previous request. 

        kwargs.setdefault('stream', self.stream) 

        kwargs.setdefault('verify', self.verify) 

        kwargs.setdefault('cert', self.cert) 

        kwargs.setdefault('proxies', self.proxies) 

 

        # It's possible that users might accidentally send a Request object. 

        # Guard against that specific failure case. 

        if not isinstance(request, PreparedRequest): 

            raise ValueError('You can only send PreparedRequests.') 

 

        checked_urls = set() 

        while request.url in self.redirect_cache: 

            checked_urls.add(request.url) 

            new_url = self.redirect_cache.get(request.url) 

            if new_url in checked_urls: 

                break 

            request.url = new_url 

 

        # Set up variables needed for resolve_redirects and dispatching of hooks 

        allow_redirects = kwargs.pop('allow_redirects', True) 

        stream = kwargs.get('stream') 

        hooks = request.hooks 

 

        # Get the appropriate adapter to use 

        adapter = self.get_adapter(url=request.url) 

 

        # Start time (approximately) of the request 

        start = datetime.utcnow() 

 

        # Send the request 

        r = adapter.send(request, **kwargs) 

 

        # Total elapsed time of the request (approximately) 

        r.elapsed = datetime.utcnow() - start 

 

        # Response manipulation hooks 

        r = dispatch_hook('response', hooks, r, **kwargs) 

 

        # Persist cookies 

        if r.history: 

 

            # If the hooks create history then we want those cookies too 

            for resp in r.history: 

                extract_cookies_to_jar(self.cookies, resp.request, resp.raw) 

 

        extract_cookies_to_jar(self.cookies, request, r.raw) 

 

        # Redirect resolving generator. 

        gen = self.resolve_redirects(r, request, **kwargs) 

 

        # Resolve redirects if allowed. 

        history = [resp for resp in gen] if allow_redirects else [] 

 

        # Shuffle things around if there's history. 

        if history: 

            # Insert the first (original) request at the start 

            history.insert(0, r) 

            # Get the last request made 

            r = history.pop() 

            r.history = history 

 

        if not stream: 

            r.content 

 

        return r 

 

    def merge_environment_settings(self, url, proxies, stream, verify, cert): 

        """Check the environment and merge it with some settings.""" 

        # Gather clues from the surrounding environment. 

        if self.trust_env: 

            # Set environment's proxies. 

            env_proxies = get_environ_proxies(url) or {} 

            for (k, v) in env_proxies.items(): 

                proxies.setdefault(k, v) 

 

            # Look for requests environment configuration and be compatible 

            # with cURL. 

            if verify is True or verify is None: 

                verify = (os.environ.get('REQUESTS_CA_BUNDLE') or 

                          os.environ.get('CURL_CA_BUNDLE')) 

 

        # Merge all the kwargs. 

        proxies = merge_setting(proxies, self.proxies) 

        stream = merge_setting(stream, self.stream) 

        verify = merge_setting(verify, self.verify) 

        cert = merge_setting(cert, self.cert) 

 

        return {'verify': verify, 'proxies': proxies, 'stream': stream, 

                'cert': cert} 

 

    def get_adapter(self, url): 

        """Returns the appropriate connnection adapter for the given URL.""" 

        for (prefix, adapter) in self.adapters.items(): 

 

            if url.lower().startswith(prefix): 

                return adapter 

 

        # Nothing matches :-/ 

        raise InvalidSchema("No connection adapters were found for '%s'" % url) 

 

    def close(self): 

        """Closes all adapters and as such the session""" 

        for v in self.adapters.values(): 

            v.close() 

 

    def mount(self, prefix, adapter): 

        """Registers a connection adapter to a prefix. 

 

        Adapters are sorted in descending order by key length.""" 

 

        self.adapters[prefix] = adapter 

        keys_to_move = [k for k in self.adapters if len(k) < len(prefix)] 

 

        for key in keys_to_move: 

            self.adapters[key] = self.adapters.pop(key) 

 

    def __getstate__(self): 

        state = dict((attr, getattr(self, attr, None)) for attr in self.__attrs__) 

        state['redirect_cache'] = dict(self.redirect_cache) 

        return state 

 

    def __setstate__(self, state): 

        redirect_cache = state.pop('redirect_cache', {}) 

        for attr, value in state.items(): 

            setattr(self, attr, value) 

 

        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE) 

        for redirect, to in redirect_cache.items(): 

            self.redirect_cache[redirect] = to 

 

 

def session(): 

    """Returns a :class:`Session` for context-management.""" 

 

    return Session()