油烟在线监测数据爬取
blame | 历史 | 原始文档
zmc
2023-12-22 d03320352e3b34f2601aa8af9fd800a27c1adada 
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

U  


§N®d˜ã@sjdZddlZddlmZddlmZddlmZmZm    Z    m


Z


mZmZe  e¡ZGdd„deƒZd    d


„ZdS)zý


    extension


    ~~~~


    Flask-CORS is a simple extension to Flask allowing you to support cross


    origin resource sharing (CORS) using a simple decorator.


 


    :copyright: (c) 2016 by Cory Dolphin.


    :license: MIT, see LICENSE for more details.


éN)Úunquote_plus)Úrequesté)Úparse_resourcesÚget_cors_optionsÚget_regexp_patternÚ


ACL_ORIGINÚ    try_matchÚset_cors_headersc@s"eZdZdZddd„Zdd„ZdS)ÚCORSa+


    Initializes Cross Origin Resource sharing for the application. The


    arguments are identical to :py:func:`cross_origin`, with the addition of a


    `resources` parameter. The resources parameter defines a series of regular


    expressions for resource paths to match and optionally, the associated


    options to be applied to the particular resource. These options are


    identical to the arguments to :py:func:`cross_origin`.


 


    The settings for CORS are determined in the following order


 


    1. Resource level settings (e.g when passed as a dictionary)


    2. Keyword argument settings


    3. App level configuration settings (e.g. CORS_*)


    4. Default settings


 


    Note: as it is possible for multiple regular expressions to match a


    resource path, the regular expressions are first sorted by length,


    from longest to shortest, in order to attempt to match the most


    specific regular expression. This allows the definition of a


    number of specific resource options, with a wildcard fallback


    for all other resources.


 


    :param resources:


        The series of regular expression and (optionally) associated CORS


        options to be applied to the given resource path.


 


        If the argument is a dictionary, it's keys must be regular expressions,


        and the values must be a dictionary of kwargs, identical to the kwargs


        of this function.


 


        If the argument is a list, it is expected to be a list of regular


        expressions, for which the app-wide configured options are applied.


 


        If the argument is a string, it is expected to be a regular expression


        for which the app-wide configured options are applied.


 


        Default : Match all and apply app-level configuration


 


    :type resources: dict, iterable or string


 


    :param origins:


        The origin, or list of origins to allow requests from.


        The origin(s) may be regular expressions, case-sensitive strings,


        or else an asterisk.


 


        :note: origins must include the schema and the port (if not port 80),


        e.g.,


        `CORS(app, origins=["http://localhost:8000", "https://example.com"])`.


 


        Default : '*'


    :type origins: list, string or regex


 


    :param methods:


        The method or list of methods which the allowed origins are allowed to


        access for non-simple requests.


 


        Default : [GET, HEAD, POST, OPTIONS, PUT, PATCH, DELETE]


    :type methods: list or string


 


    :param expose_headers:


        The header or list which are safe to expose to the API of a CORS API


        specification.


 


        Default : None


    :type expose_headers: list or string


 


    :param allow_headers:


        The header or list of header field names which can be used when this


        resource is accessed by allowed origins. The header(s) may be regular


        expressions, case-sensitive strings, or else an asterisk.


 


        Default : '*', allow all headers


    :type allow_headers: list, string or regex


 


    :param supports_credentials:


        Allows users to make authenticated requests. If true, injects the


        `Access-Control-Allow-Credentials` header in responses. This allows


        cookies and credentials to be submitted across domains.


 


        :note: This option cannot be used in conjunction with a '*' origin


 


        Default : False


    :type supports_credentials: bool


 


    :param max_age:


        The maximum time for which this CORS request maybe cached. This value


        is set as the `Access-Control-Max-Age` header.


 


        Default : None


    :type max_age: timedelta, integer, string or None


 


    :param send_wildcard: If True, and the origins parameter is `*`, a wildcard


        `Access-Control-Allow-Origin` header is sent, rather than the


        request's `Origin` header.


 


        Default : False


    :type send_wildcard: bool


 


    :param vary_header:


        If True, the header Vary: Origin will be returned as per the W3


        implementation guidelines.


 


        Setting this header when the `Access-Control-Allow-Origin` is


        dynamically generated (e.g. when there is more than one allowed


        origin, and an Origin than '*' is returned) informs CDNs and other


        caches that the CORS headers are dynamic, and cannot be cached.


 


        If False, the Vary header will never be injected or altered.


 


        Default : True


    :type vary_header: bool


    NcKs ||_|dk    r|j|f|ŽdS©N)Ú_optionsÚinit_app)ÚselfÚappÚkwargs©rúKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\flask_cors/extension.pyÚ__init__sz CORS.__init__csœtˆ|j|ƒ‰tˆ d¡ƒ}‡‡fdd„|Dƒ}dd„|Dƒ}t d|¡t|ƒ‰ˆ ˆ¡ˆ dd¡r˜‡‡fd    d


„}tˆdƒr˜|ˆj    ƒˆ_    |ˆj


ƒˆ_


dS)NÚ    resourcescs g|]\}}|tˆˆ|ƒf‘qSr)r©Ú.0ÚpatternÚopts)rÚoptionsrrÚ


<listcomp>žsÿz!CORS.init_app.<locals>.<listcomp>cSsi|]\}}t|ƒ|“qSr)rrrrrÚ


<dictcomp>¥sz!CORS.init_app.<locals>.<dictcomp>z#Configuring CORS with resources: %sZintercept_exceptionsTcs‡‡‡fdd„}|S)Ncsˆˆ ˆ||Ž¡ƒSr)Z make_response)Úargsr)rÚcors_after_requestÚfrrÚwrapped_function¯szICORS.init_app.<locals>._after_request_decorator.<locals>.wrapped_functionr)rr )rr)rrÚ_after_request_decorator®sz/CORS.init_app.<locals>._after_request_decoratorÚhandle_exception)rr rÚgetÚLOGÚdebugÚmake_after_request_functionZ after_requestÚhasattrr"Zhandle_user_exception)rrrrZresources_humanr!r)rrrrr’s$þ


 


ÿÿz CORS.init_app)N)Ú__name__Ú


__module__Ú__qualname__Ú__doc__rrrrrrrsq


rcs‡fdd„}|S)Ncsx|jdk    r$|j t¡r$t d¡|Sttjƒ}ˆD]6\}}t||ƒr2t dtjt    |ƒ|¡t


||ƒqtq2t d¡|S)Nz*CORS have been already evaluated, skippingz=Request to '%s' matches CORS resource '%s'. Using options: %szNo CORS rule matches)Úheadersr#rr$r%rrÚpathr    rr


)ÚrespZnormalized_pathZ    res_regexZres_options©rrrrºs


 


 


ÿ


 


z7make_after_request_function.<locals>.cors_after_requestr)rrrr/rr&¹sr&)r+ÚloggingÚurllib.parserZflaskrÚcorerrrrr    r


Ú    getLoggerr(r$Úobjectrr&rrrrÚ<module>s