~+huddlZddlmZddlmZddlmZddlmZddlm Z  ddl Z ddl m Z dd lmZdd lmZmZdd lmZdd lmZd ZGddeZGddeZdZGddeZGddeZgdZGddeZ Gddee Z!GddeZ"Gdde!Z#d Z$y#e $r ddl Z ddl m Z YwxYw)!N)path)chain)six)map)is_url) has_magic) get_cache) get_versioner get_manifest) get_updater)urlparse) Environment RegisterErrorc eZdZy)rN)__name__ __module__ __qualname__@/var/www/html/venv/lib/python3.12/site-packages/webassets/env.pyrrsrrcNeZdZdZdZd dZdZdZdZdZ d Z d Z d Z d Z y) ConfigStoragea This is the backend which :class:`Environment` uses to store its configuration values. Environment-subclasses like the one used by ``django-assets`` will often want to use a custom ``ConfigStorage`` as well, building upon whatever configuration the framework is using. The goal in designing this class therefore is to make it easy for subclasses to change the place the data is stored: Only _meth:`__getitem__`, _meth:`__setitem__`, _meth:`__delitem__` and _meth:`__contains__` need to be implemented. One rule: The default storage is case-insensitive, and custom environments should maintain those semantics. A related reason is why we don't inherit from ``dict``. It would require us to re-implement a whole bunch of methods, like pop() etc. c||_yNenv)selfrs r__init__zConfigStorage.__init__0s rNcH |j|S#t$r|cYSwxYwr) __getitem__KeyError)rkeydefaults rgetzConfigStorage.get3s, ##C( ( N s  !!c<|D]}|j|||yr) __setitem__)rdr#s rupdatezConfigStorage.update9s% *C   S!C& ) *rcT||vr|j|||S|j|Sr)r'r!rr#values r setdefaultzConfigStorage.setdefault=s/ d?   S% (L$$rctrNotImplementedErrorrr#s r __contains__zConfigStorage.__contains__C !##rctrr/r1s rr!zConfigStorage.__getitem__Fr3rctrr/r+s rr'zConfigStorage.__setitem__Ir3rctrr/r1s r __delitem__zConfigStorage.__delitem__Lr3rcy)zlFor deprecated keys, fake the values as good as we can. Subclasses need to call this in __getitem__.Nrr1s r_get_deprecatedzConfigStorage._get_deprecatedOs rcy)zSame for __setitem__.Nrr+s r_set_deprecatedzConfigStorage._set_deprecatedTs rr)rrr__doc__rr%r)r-r2r!r'r7r9r;rrrrrs9& *% $$$$  rrcT||dddk7xrdxsdz }tj||S)zJoin url prefix with fragment.N/)rurljoin)prefixfragments rurl_prefix_joinrDYs6 fRSkS (S.B.F   FH --rcLeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z y ) ResolveraResponsible for resolving user-specified :class:`Bundle` contents to actual files, as well as to urls. In this base version, this is essentially responsible for searching the load path for the queried file. A custom implementation of this class is tremendously useful when integrating with frameworks, which usually have some system to spread static files across applications or modules. The class is designed for maximum extensibility. c,d}t|||S)zZEvaluates a glob expression. Yields a sorted list of absolute filenames. c3Ktj||}tj|D]/}tj|rtj |1ywr)rjoinglobiglobisdirnormpath)basedirexprfilenames rglob_generatorz%Resolver.glob..glob_generatorrsL99Wd+D JJt, .::h'mmH-- .sAA!)sorted)rrNrOrQs rrJz Resolver.globns .nWd344rctj||}t|r|j||Stj|r|St d|z)zSearches for ``item`` within ``directory``. Is able to resolve glob instructions. Subclasses can call this when they have narrowed done the location of a bundle item to a single directory. z'%s' does not exist)rrIrrJexistsIOError)r directoryitemrOs rconsider_single_directoryz"Resolver.consider_single_directory}sNyyD) T?99Y- -{{4  /$67 7rc:|j|j|S)zjThis is called by :meth:`search_for_source` when no :attr:`Environment.load_path` is set. )rXrVrctxrWs rsearch_env_directoryzResolver.search_env_directorys--cmmTBBrc t|r6g}|jD]#}|j|j||%|S|jD]}|j||}|s|cSt d|d|j)zThis is called by :meth:`search_for_source` when a :attr:`Environment.load_path` is set. If you want to change how the load path is processed, overwrite this method. 'z' not found in load path: )r load_pathextendrJrU)rr[rWresultrs rsearch_load_pathzResolver.search_load_paths T?F  5 diid34 5M   "4.!M "cmm%& &rcb|jr|j||S|j||S)a$Called by :meth:`resolve_source` after determining that ``item`` is a relative filesystem path. You should always overwrite this method, and let :meth:`resolve_source` deal with absolute paths, urls and other types of items that a bundle may contain. )r_rbr\rZs rsearch_for_sourcezResolver.search_for_sources1 ==((d3 3,,S$7 7rct|jj} |j|j|j fttd|}|jddtj|}|D]U\}}|j|s|t|dzd}|jtjd}t!||cSt#d|z#t $rYwxYw) a2Searches the environment-wide url mapping (based on the urls assigned to each directory in the load path). Returns the correct url for ``filepath``. Subclasses should be sure that they really want to call this method, instead of simply falling back to ``super()``. cbtjtj|d|dfS)Nrr )rrMabspath)p_us rz,Resolver.query_url_mapping..s%t||CF';.s3qt9rT)r#reverser Nr?zCannot determine url for %s)list url_mappingitemsappendrVurlEnvironmentErrorrsortrrM startswithrkreplaceosseprD ValueError)rr[filepathmappingneedle candidaterrrel_paths rquery_url_mappingzResolver.query_url_mappingss,,./  NNCMM3773 4 s E   ,d ;x(% 6NIs  +!#i.1"4"56$++BFFC8&sH55 66ABB)    s'C33 C?>C?ct|tjs|St|st j |r|S|j ||S)aGiven ``item`` from a Bundle's contents, this has to return the final value to use, usually an absolute filesystem path. .. note:: It is also allowed to return urls and bundle instances (or generally anything else the calling :class:`Bundle` instance may be able to handle). Indeed this is the reason why the name of this method does not imply a return type. The incoming item is usually a relative path, but may also be an absolute path, or a url. These you will commonly want to return unmodified. This method is also allowed to resolve ``item`` to multiple values, in which case a list should be returned. This is commonly used if ``item`` includes glob instructions (wildcards). .. note:: Instead of this, subclasses should consider implementing :meth:`search_for_source` instead. ) isinstancer string_typesrrisabsrdrZs rresolve_sourcezResolver.resolve_sourcesC6$ 0 01K $<4::d+K%%c400rcBtj|j|S)a}Given ``target``, this has to return the absolute filesystem path to which the output file of ``bundle`` should be written. ``target`` may be a relative or absolute path, and is usually taking from the :attr:`Bundle.output` property. If a version-placeholder is used (``%(version)s``, it is still unresolved at this point. )rrIrV)rr[targetbundles rresolve_output_to_pathzResolver.resolve_output_to_pathsyy//rc&|j||S)aGiven the absolute filesystem path in ``filepath``, as well as the original value from :attr:`Bundle.contents` which resolved to this path, this must return the absolute url through which the file is to be referenced. Depending on the use case, either the ``filepath`` or the ``item`` argument will be more helpful in generating the url. This method should raise a ``ValueError`` if the url cannot be determined. )r)rr[rzrWs rresolve_source_to_urlzResolver.resolve_source_to_url s%%c844rc|tj|st|j|S|j ||S)a?Given ``target``, this has to return the url through which the output file can be referenced. ``target`` may be a relative or absolute path, and is usually taking from the :attr:`Bundle.output` property. This is different from :meth:`resolve_source_to_url` in that you do not passed along the result of :meth:`resolve_output_to_path`. This is because in many use cases, the filesystem is not available at the point where the output url is needed (the media server may on a different machine). )rrrDrrr)rr[rs rresolve_output_to_urlzResolver.resolve_output_to_urls8zz&!#377F3 3))#v6 6rN)rrrr<rJrXr\rbrdrrrrrrrrrFrF`s=  58 C &0 8 CD!1F 0 57rrFcLeZdZdZdZdZdZdZdZeZ dZ dZ d Z d Z y ) BundleRegistryc i|_g|_yr)_named_bundles _anon_bundlesrs rrzBundleRegistry.__init__2s rchttj|j|jSr)rr itervaluesrrrs r__iter__zBundleRegistry.__iter__6s$S^^D$7$78$:L:LMMrc |j|Srrrnames rr!zBundleRegistry.__getitem__9s""4((rc||jvSrrrs rr2zBundleRegistry.__contains__<st****rcXt|jt|jzSr)rkrrrs r__len__zBundleRegistry.__len__?s#4&&'#d.@.@*AAArcy)NTrrs r__bool__zBundleRegistry.__bool__Bsrc ddlm}t|tr/|s-|s+|j D]\}}|j ||yt |dk(r tdt |dk(r|st|d|r|d}n||i|}|js|j||S||jvr6|j||k(r |Stdd|d|j|z||j|<||_ |S) aRegister a :class:`Bundle` with the given ``name``. This can be called in multiple ways: - With a single :class:`Bundle` instance:: env.register('jquery', jquery_bundle) - With a dictionary, registering multiple bundles at once: bundles = {'js': js_bundle, 'css': css_bundle} env.register(bundles) .. note:: This is a convenient way to use a :doc:`loader `: env.register(YAMLLoader('assets.yaml').load_bundles()) - With many arguments, creating a new bundle on the fly:: env.register('all_js', jquery_bundle, 'common.js', filters='rjsmin', output='packed.js') r BundleNrz#at least two arguments are requiredz%Another bundle is already registered zas "z": ) rrrdictrpregisterrk TypeErrormergedecompose_bundlerrr)rrargskwargsrrs rrzBundleRegistry.registerFs2 # dD !$v $  , f dF+ ,  t9>AB B4yA~fDGV1La00<<,,T6::t***&&t,6M ((O9=t?R?RSW?X(Y)Z[[-3##D)! MrcV|D]$}|jj|||_&y)a.Register a list of bundles with the environment, without naming them. This isn't terribly useful in most cases. It exists primarily because in some cases, like when loading bundles by searching in templates for the use of an "assets" tag, no name is available. N)rrqr)rbundlesrs raddzBundleRegistry.add~s. F    % %f -FJ rcddlm}|js td|jD]}t ||std||_g}|j}|D])\}}|j|||} |j| +|S)Nr rz.If `merge` is False, an output must be definedz4Nested bundles are not allowed when `merge` is False) rroutputrcontentsrrresolve_contentsregister_decomposedrq) rrrrcontentrr_rgnbs rrzBundleRegistry.decompose_bundles"}} PQ Q \G'6*#$Z[[ \ **," JAw))$@B NN2  rcTddlm}tj||j}tj |}tj |\}}tj |\} } |rtj||n|} |jjd|jd| jd| jd} ||| |j|j|j|j} |j| _|j!| | S)Nr rz%(name)sz%(path)sz%(ext)s.)rfiltersdependsremove_duplicatesextra)rrrrelpathrVbasenamesplitextrIrrvstriprrrr_configr)rrrrgrrrrPrrzfileextnew_namer new_bundles rrz"BundleRegistry.register_decomposeds",,w7==)mmH- ! MM'2'04499T8,( MM WZ * WZ * WY c 2 3   NNNN$66,,  $^^ }}Xz22rN)rrrrrr!r2rr __nonzero__rrrrrrrrr0s< N)+BK6p &3rr) rVrrdebugcacheupdater auto_build url_expireversionsmanifestr_rocache_file_modeceZdZdZdZd,dZdZdZeeedZ d Z d Z ee e d Z d Z d Zeee dZdZdZeeedZdZdZeeedZdZdZeeedZdZdZeeedZdZdZeeedZdZdZ ee ed Z!d!Z"d"Z#ee#e"d#Z$d$Z%d%Z&ee&e%d&Z'd'Z(d(Z)ee)e(d)Z*d*Z+d+Z,ee,e+Z-y)-ConfigurationContextahInterface to the webassets configuration key-value store. This wraps the :class:`ConfigStorage`` interface and adds some helpers. It allows attribute-access to the most important settings, and transparently instantiates objects, such that ``env.manifest`` gives you an object, even though the configuration contains the string "json". c||_yr_storage)rstorages rrzConfigurationContext.__init__s  rNc^|jj||r||j|<yy)znAppends ``path`` to :attr:`load_path`, and adds a corresponding entry to :attr:`url_mapping`. N)r_rqro)rrrrs r append_pathz ConfigurationContext.append_paths. d# %(D  T " rc"||jd<yNrr)rrs r _set_debugzConfigurationContext._set_debugs!& grc |jdSrrrs r _get_debugzConfigurationContext._get_debugs}}W%%raOEnable/disable debug mode. Possible values are: ``False`` Production mode. Bundles will be merged and filters applied. ``True`` Enable debug mode. Bundles will output their individual source files. *"merge"* Merge the source files, but do not apply filters. )docc"||jd<yNrr)rmodes r_set_cache_file_modez)ConfigurationContext._set_cache_file_modes+/ '(rc |jdSrrrs r_get_cache_file_modez)ConfigurationContext._get_cache_file_modes}}.//raControls the mode of files created in the cache. The default mode is 0600. Follows standard unix mode. Possible values are any unix mode, e.g.: ``0660`` Enable the group read+write bits ``0666`` Enable world read+write bits c"||jd<yNrr)renables r _set_cachezConfigurationContext._set_caches!' grczt|jd|}||jdk7r||jd<|Sr)r r)rrs r _get_cachezConfigurationContext._get_caches;$--0$7 DMM'* *%*DMM' " raControls the behavior of the cache. The cache will speed up rebuilding of your bundles, by caching individual filter results. This can be particularly useful while developing, if your bundles would otherwise take a long time to rebuild. Possible values are: ``False`` Do not use the cache. ``True`` (default) Cache using default location, a ``.webassets-cache`` folder inside :attr:`directory`. *custom path* Use the given directory as the cache directory. c"||jd<yNrr)rr,s r_set_auto_buildz$ConfigurationContext._set_auto_builds&+ l#rc |jdSrrrs r_get_auto_buildz$ConfigurationContext._get_auto_build}}\**raSControls whether bundles should be automatically built, and rebuilt, when required (if set to ``True``), or whether they must be built manually be the user, for example via a management command. This is a good setting to have enabled during debugging, and can be very convenient for low-traffic sites in production as well. However, there is a cost in checking whether the source files have changed, so if you care about performance, or if your build process takes very long, then you may want to disable this. By default automatic building is enabled. c"||jd<y)Nrrrrs r _set_manifestz"ConfigurationContext._set_manifest'$, j!rc|t|jd|}||jdk7r||jd<|S)Nrr)r rrs r _get_manifestz"ConfigurationContext._get_manifest)s; j 9tD t}}Z0 0(0DMM* %ra4A manifest persists information about the versions bundles are at. The Manifest plays a role only if you insert the bundle version in your output filenames, or append the version as a querystring to the url (via the ``url_expire`` option). It serves two purposes: - Without a manifest, it may be impossible to determine the version at runtime. In a deployed app, the media files may be stored on a different server entirely, and be inaccessible from the application code. The manifest, if shipped with your application, is what still allows to construct the proper URLs. - Even if it were possible to determine the version at runtime without a manifest, it may be a costly process, and using a manifest may give you better performance. If you use a hash-based version for example, this hash would need to be recalculated every time a new process is started. Valid values are: ``"cache"`` (default) The cache is used to remember version information. This is useful to avoid recalculating the version hash. ``"file:{path}"`` Stores version information in a file at {path}. If not path is given, the manifest will be stored as ``.webassets-manifest`` in ``Environment.directory``. ``"json:{path}"`` Same as "file:{path}", but uses JSON to store the information. ``False``, ``None`` No manifest is used. Any custom manifest implementation. c"||jd<yNrrrrs r _set_versionsz"ConfigurationContext._set_versionsYrrcxt|jd}||jdk7r||jd<|Sr)r rrs r _get_versionsz"ConfigurationContext._get_versions[s9 z!:; t}}Z0 0(0DMM* %raDefines what should be used as a Bundle ``version``. A bundle's version is what is appended to URLs when the ``url_expire`` option is enabled, and the version can be part of a Bundle's output filename by use of the ``%(version)s`` placeholder. Valid values are: ``timestamp`` The version is determined by looking at the mtime of a bundle's output file. ``hash`` (default) The version is a hash over the output file's content. ``False``, ``None`` Functionality that requires a version is disabled. This includes the ``url_expire`` option, the ``auto_build`` option, and support for the %(version)s placeholder. Any custom version implementation. c"||jd<yNrrrrs r set_updaterz ConfigurationContext.set_updaterzs#* i rcxt|jd}||jdk7r||jd<|Sr)r rrs rr z ConfigurationContext.get_updater|s9dmmI67 dmmI. .'.DMM) $rayControls how the ``auto_build`` option should determine whether a bundle needs to be rebuilt. ``"timestamp"`` (default) Rebuild bundles if the source file timestamp exceeds the existing output file's timestamp. ``"always"`` Always rebuild bundles (avoid in production environments). Any custom version implementation. c"||jd<yNrr)rrs r_set_url_expirez$ConfigurationContext._set_url_expires&0 l#rc |jdSrrrs r_get_url_expirez$ConfigurationContext._get_url_expirerraIf you send your assets to the client using a *far future expires* header (to minimize the 304 responses your server has to send), you need to make sure that assets will be reloaded by the browser when they change. If this is set to ``True``, then the Bundle URLs generated by webassets will have their version (see ``Environment.versions``) appended as a querystring. An alternative approach would be to use the ``%(version)s`` placeholder in the bundle output file. The default behavior (indicated by a ``None`` value) is to add an expiry querystring if the bundle does not use a version placeholder. c"||jd<y)NrVr)rrVs r_set_directoryz#ConfigurationContext._set_directory%. k"rcx tj|jdS#t$r t dwxYw)NrVz-The environment has no "directory" configured)rrgrr"rsrs r_get_directoryz#ConfigurationContext._get_directorysC A<< k :; ; A"?A A As!$9zThe base directory to which all paths will be relative to, unless :attr:`load_path` are given, in which case this will only serve as the output directory. In the url space, it is mapped to :attr:`urls`. c"||jd<y)Nrrr)rrrs r_set_urlzConfigurationContext._set_urls" ercR |jdS#t$r tdwxYw)Nrrz'The environment has no "url" configured)rr"rsrs r_get_urlzConfigurationContext._get_urls5 ;==' ' ;"9; ; ;s&zThe url prefix used to construct urls for files in :attr:`directory`. To define url spaces for other directories, see :attr:`url_mapping`. c"||jd<yNr_r)rr_s r_set_load_pathz#ConfigurationContext._set_load_pathrrc |jdSr rrs r_get_load_pathz#ConfigurationContext._get_load_paths}}[))ra!An list of directories that will be searched for source files. If this is set, source files will only be looked for in these directories, and :attr:`directory` is used as a location for output files only. .. note: You are free to add :attr:`directory` to your load path as well. .. note: Items on the load path are allowed to contain globs. To modify this list, you should use :meth:`append_path`, since it makes it easy to add the corresponding url prefix to :attr:`url_mapping`. c"||jd<yNror)rros r_set_url_mappingz%ConfigurationContext._set_url_mappings'2 m$rc |jdSrrrs r_get_url_mappingz%ConfigurationContext._get_url_mappings}}]++raiA dictionary of directory -> url prefix mappings that will be considered when generating urls, in addition to the pair of :attr:`directory` and :attr:`url`, which is always active. You should use :meth:`append_path` to add directories to the load path along with their respective url spaces, instead of modifying this setting directly. c"||jd<yNresolverr)rrs r _set_resolverz"ConfigurationContext._set_resolverrrc |jdSrrrs r _get_resolverz"ConfigurationContext._get_resolvers}}Z((rr).rrrr<rrrrpropertyrrrrrrrrrrrrrrrrrr rrrrrrrVrr rrr rr_rrrorrrrrrrrs )'& Z  E0035I   O( Z E&,+/?   J-  }() HV-  } H4+ {K   G1+/? J$/A  I#; 8X C/* I&3,+-= K-) }5Hrrc.eZdZdZdZeZdZedZ y)BaseEnvironmentzrAbstract base class for :class:`Environment` with slightly more generic assumptions, to ease subclassing. Nc Ttj||j||_tj||j|j j dd|j j dd|j j dd|j j dd|j j dd|j j dd |j j d d |j j d g|j j d i|j j d|j|j j dd|j j|y)NrFrTrrrrhashr timestampr_rorr) rrconfig_storage_classrrconfigr-resolver_classr))rr!s rrzBaseEnvironment.__init__s0%006 %%dDLL9 w. w- |T2 |T2 z73 z62 y+6 {B/ }b1 z4+>+>+@A 0$7 6"rc|jS)zrGs #" 0  + I : F: z.M7vM7`F3VF3\ j66j6Z 'n&:'T, ,, / ks B..C?C