
    \jc                     H   d Z ddlZddlZddlZddlZddlZddlZddlZddlm	Z	m
Z
mZmZmZmZ ddlmZmZmZmZmZ ddlmZ 	 ddlmZ eefZ ej:                  e      Zd	 Z d
 Z!d Z" G d d      Z# G d d      Z$ G d de$      Z% G d d      Z&y# e$ r	 ddlmZ Y Vw xY w)zt
Django-environ allows you to utilize 12factor inspired environment
variables to configure your Django application.
    N)parse_qsParseResultunquoteunquote_plusurlparse
urlunparse   )DJANGO_POSTGRESImproperlyConfiguredjsonPYMEMCACHE_DRIVERREDIS_DRIVER)FileAwareMapping)PathLike)PurePathc                 \    	 t        j                  |       S # t        t        f$ r | cY S w xY wN)astliteral_eval
ValueErrorSyntaxError)values    9/root/env/lib/python3.12/site-packages/environ/environ.py_castr   1   s1    &&$ s    ++c                 T    t        | d      r| j                         rt        |       S | S )zReturn int if possible.isdigit)hasattrr   intvs    r   	_cast_intr!   ;   s"    Q	*qyy{3q6AA    c                 <    t        | t              rt        |       S | S r   )
isinstancestrr   r   s    r   _cast_urlstrr&   @   s    #As+71:22r"   c                       e Zd ZdZd Zy)NoValuezRepresent of no value object.c                 L    dj                  | j                  j                        S )Nz<{}>)format	__class____name__selfs    r   __repr__zNoValue.__repr__G   s    }}T^^4455r"   N)r,   
__module____qualname____doc__r/    r"   r   r(   r(   D   s
    '6r"   r(   c                      e Zd ZdZej
                  Z e       ZdZ	e
Zg dZdD  cg c]  }d|z   	 c}} ZdZi deded	ed
edddddddddddddddddddddddd Zg d!Zd"Zd#d$d%d&d'ed(eeed)
Zg d*Zd+Zd,d,d,d,d-d.d/d0d1Zd2d3gZd4Zd5d6d7d8d9d:d;d<d=Zd>Zd? Zd@edAfdBZdC ZedAfdDZ edEfdFZ!efdGZ"efdHZ#efdIZ$efdJZ%d@efdKZ&d@efdLZ'e(efdMZ(efdNZ)eed@fdOZ*e*Z+eed@fdPZ,e,Z-eed@fdQZ.e.Z/eed@fdRZ0efdSZ1d@edAfdTZ2e3dU        Z4e3d[dV       Z5e3d[dW       Z6e3d[dX       Z7e3d[dY       Z8e3d\dZ       Z9y@c c}} w )]Enva3  Provide scheme-based lookups of environment variables so that each
    caller doesn't have to pass in ``cast`` and ``default`` parameters.

    Usage:::

        import environ
        import os

        env = environ.Env(
            # set casting, default value
            MAIL_ENABLED=(bool, False),
            SMTP_LOGIN=(str, 'DEFAULT')
        )

        # Set the project base directory
        BASE_DIR = os.path.dirname(
            os.path.dirname(os.path.abspath(__file__))
        )

        # Take environment variables from .env file
        environ.Env.read_env(os.path.join(BASE_DIR, '.env'))

        # False if not in os.environ due to casting above
        MAIL_ENABLED = env('MAIL_ENABLED')

        # 'DEFAULT' if not in os.environ due to casting above
        SMTP_LOGIN = env('SMTP_LOGIN')
    )trueonokyyes1)postgres
postgresqlpsqlpgsqlpostgis) 257elasticsearchDATABASE_URLr<   r=   r>   r?   r@   z&django.contrib.gis.db.backends.postgismysqlzdjango.db.backends.mysqlmysql2zmysql-connectorzmysql.connector.djangomysqlgisz$django.contrib.gis.db.backends.mysqlmssqlzsql_server.pyodbcoraclezdjango.db.backends.oraclepyodbcredshiftdjango_redshift_backend
spatialitez)django.contrib.gis.db.backends.spatialitesqlitezdjango.db.backends.sqlite3ldapzldapdb.backends.ldap)CONN_MAX_AGEATOMIC_REQUESTS
AUTOCOMMITDISABLE_SERVER_SIDE_CURSORSCONN_HEALTH_CHECKS	CACHE_URLz+django.core.cache.backends.db.DatabaseCachez+django.core.cache.backends.dummy.DummyCachez3django.core.cache.backends.filebased.FileBasedCachez-django.core.cache.backends.locmem.LocMemCachez3django.core.cache.backends.memcached.MemcachedCachez1django.core.cache.backends.memcached.PyLibMCCache)
dbcache
dummycache	filecachelocmemcachememcache
pymemcachepylibmc
rediscacheredisrediss)TIMEOUT
KEY_PREFIXVERSIONKEY_FUNCTIONBINARY	EMAIL_URLz+django.core.mail.backends.smtp.EmailBackendz.django.core.mail.backends.console.EmailBackendz0django.core.mail.backends.filebased.EmailBackendz-django.core.mail.backends.locmem.EmailBackendz,django.core.mail.backends.dummy.EmailBackend)smtpsmtpssmtp+tlssmtp+sslconsolemailfilemail
memorymail	dummymailEMAIL_USE_TLSEMAIL_USE_SSL
SEARCH_URLzAhaystack.backends.elasticsearch_backend.ElasticsearchSearchEnginezChaystack.backends.elasticsearch2_backend.Elasticsearch2SearchEnginezChaystack.backends.elasticsearch5_backend.Elasticsearch5SearchEnginezChaystack.backends.elasticsearch7_backend.Elasticsearch7SearchEnginez)haystack.backends.solr_backend.SolrEnginez-haystack.backends.whoosh_backend.WhooshEnginez-haystack.backends.xapian_backend.XapianEnginez-haystack.backends.simple_backend.SimpleEngine)rE   elasticsearch2elasticsearch5elasticsearch7solrwhooshxapiansimplecloudsqlc                 <    d| _         d| _        d| _        || _        y )NTFrA   )
smart_castescape_proxyprefixscheme)r.   r   s     r   __init__zEnv.__init__   s    !r"   NFc                 ,    | j                  ||||      S )Ncastdefaultparse_default	get_value)r.   varr   r   r   s        r   __call__zEnv.__call__   s$    ~~'	  
 	
r"   c                     || j                   v S r   )ENVIRON)r.   r   s     r   __contains__zEnv.__contains__   s    dll""r"   c                 h    | j                  |t        |      }|rt        j                  dd|      S |S )z
        :rtype: str
        r   r   z	(\\r)?\\nz\n)r   r%   resub)r.   r   r   	multiliner   s        r   r%   zEnv.str   s3     sg>66,u55r"   utf8c                 p    | j                  |t        |      }t        |d      r|j                  |      S |S )z
        :rtype: bytes
        r   encode)r   r%   r   r   )r.   r   r   encodingr   s        r   bytesz	Env.bytes   s6     sg>5(#<<))r"   c                 2    | j                  |t        |      S )z
        :rtype: bool
        r   )r   boolr.   r   r   s      r   r   zEnv.bool   s     ~~cg~>>r"   c                 2    | j                  |t        |      S )z
        :rtype: int
        r   )r   r   r   s      r   r   zEnv.int   s     ~~cW~==r"   c                 2    | j                  |t        |      S )z
        :rtype: float
        r   )r   floatr   s      r   r   z	Env.float   s     ~~cw~??r"   c                 F    | j                  |t        j                  |      S )z'
        :returns: Json parsed
        r   )r   r   loadsr   s      r   r   zEnv.json   s     ~~c

G~DDr"   c                 H    | j                  ||st        |      S |g|      S )z
        :rtype: list
        r   )r   listr.   r   r   r   s       r   r   zEnv.list   s<     ~~!  
 	
(,v  
 	
r"   c                 H    | j                  ||st        |      S |f|      S )z
        :rtype: tuple
        r   )r   tupler   s       r   r   z	Env.tuple  s<     ~~"  
 	
)-  
 	
r"   c                 *    | j                  |||      S )z
        :rtype: dict
        r   r   r   s       r   dictzEnv.dict  s     ~~cg~>>r"   c                 4    | j                  |t        |d      S )z2
        :rtype: urllib.parse.ParseResult
        Tr   )r   r   r   s      r   urlzEnv.url  s&     ~~	  
 	
r"   c                 J    | j                  | j                  ||      |      S )zReturns a config dictionary, defaulting to DATABASE_URL.

        The db method is an alias for db_url.

        :rtype: dict
        r   engine)db_url_configr   r.   r   r   r   s       r   db_urlz
Env.db_url  s/     !!NN3N0 " 
 	
r"   c                 J    | j                  | j                  ||      |      S )zReturns a config dictionary, defaulting to CACHE_URL.

        The cache method is an alias for cache_url.

        :rtype: dict
        r   backend)cache_url_configr   r.   r   r   r   s       r   	cache_urlzEnv.cache_url-  /     $$HHS'H* % 
 	
r"   c                 J    | j                  | j                  ||      |      S )zReturns a config dictionary, defaulting to EMAIL_URL.

        The email method is an alias for email_url.

        :rtype: dict
        r   r   )email_url_configr   r   s       r   	email_urlzEnv.email_url;  r   r"   c                 J    | j                  | j                  ||      |      S )zUReturns a config dictionary, defaulting to SEARCH_URL.

        :rtype: dict
        r   r   )search_url_configr   r   s       r   
search_urlzEnv.search_urlI  s/    
 %%HHS'H* & 
 	
r"   c                 <    t        | j                  ||      fi |S )z
        :rtype: Path
        r   )Pathr   )r.   r   r   kwargss       r   pathzEnv.pathS  s!     DNN3N8CFCCr"   c                    t         j                  d|||       dj                  | j                  |      }|| j                  v r@| j                  |   }	 t        |      dk(  }|r|s|d   }|| j                  u r	 |d   }n|s|}	 | j                  |   }t        |t              rd	nd
}t        |t              rdnd}t        |d      r6|j                  |      r%|j!                  |      }| j#                  |||      }| j$                  rt        |d      r|j'                  ||      }| j(                  r||t        |t*              st-        |      }||dk(  rdn|}||k7  s|r|| j/                  ||      }|S # t        $ r d}Y 'w xY w# t        $ r Y w xY w# t        $ r8}	|| j                  u rdj                  |      }
t        |
      |	|}Y d}	~	Ed}	~	ww xY w)a  Return value for given environment variable.

        :param str var:
            Name of variable.
        :param collections.abc.Callable or None cast:
            Type to cast return value as.
        :param default:
             If var not present in environ, return this instead.
        :param bool parse_default:
            Force to parse default.
        :returns: Value from environment or default (if set).
        :rtype: typing.IO[typing.Any]
        z)get '%s' casted as '%s' with default '%s'z{}{}   Fr   r	   zSet the {} environment variableN   $$s   \$z\$
startswithr   replacerA   )loggerdebugr*   r~   r   len	TypeErrorNOTSET
IndexErrorr   KeyErrorr   r$   r   r   r   lstripr   r}   r   r|   r(   typeparse_value)r.   r   r   r   r   var_namevar_infohas_defaultr   exc	error_msgr~   escapes                r   r   zEnv.get_valueY  s    	7w	  ==c2t{{"{{8,H$!(mq0 #A;Ddkk)"*1+ #D	LL*E $E51s%eU35,'E,<,<V,DLL(ENN5tWNEE	!:MM&&1E ??| 3"7G4G}ERKUG%2C$$UD1E]  $#$ &   	$++%=DDSI	*953>E	s<   E: 9F F :F	F		FF	G%-GGc                    	
 ||S |t         u r	 t        |      dk7  }|S t        |t              r:t        t        |d   |j                  d      D cg c]  }|s|	 c}            }|S t        |t              rZ|j                  d      j                  d      j                  d      }t        t        |d   |D cg c]  }|s|	 c}            }|S t        |t              r|j                  dt              |j                  dt              	|j                  di       
t        t         	
fd|j                  d	      D cg c]  }|s|j                  d
       c}            }|S |t        u r=t        |j                  d      D cg c]  }|s|j                  d
d       c}      }|S |t        u r#|j                  d      D cg c]  }|s|	 }}|S |t        u rM|j                  d      j                  d      j                  d      }t        |D cg c]  }|s|	 c}      }|S |t        u rut        j                   dd|      }t        j                  d|      }t#        |      dk(  r|d   }n'dj%                  dj'                  |dd       |d         }t        |      }|S  ||      }|S # t        $ r  |j                          j                  v }Y |S w xY wc c}w c c}w c c}w c c}w c c}w c c}w )zParse and cast provided value

        :param value: Stringed value.
        :param cast: Type to cast return value as.

        :returns: Casted value
        r   ,()keyr   r   c                 j     | d         j                  | d   j                  | d               fS )Nr   r	   )r   get)kvclskey_cast
value_castvalue_cast_by_keys    r   <lambda>z!Env.parse_value.<locals>.<lambda>  s<    RUOOO1)--beZ@ r"   ;=r	   z[^\d,.-]rA   z[,.]z{}.{})r   r   r   lowerBOOLEAN_TRUE_STRINGSr$   r   mapsplitr   stripr   r   r%   r   r   r   r   r*   join)r   r   r   xvalr    	float_strpartsr   r   r   s   `       @@@r   r   zEnv.parse_value  s    <L4<BE
aV Q d#T!W%++c2B&HQaq&HIJEN M e$++c"((-33C8C#d1g3'<a!'<=>EH G d#xxs+H'3/J $ 4 ,1;;s+;CCs3C	 	E> + T\5;;s3CIaq!''#q/IJE( ' T\ %C 061AQ6E6$ # U]++c"((-33C8Cc/Q1/0E  U]{B6I HHWi0E5zQ!!H	#NN27752;+?rK	)$E  KEU  B)A)AAR UB 'I (= D J6 0sY   J< K(K(=K-K-K2K2K7K7K<K< L(L<%K%$K%c           	         t        || j                        s"|dk(  r| j                  d   ddS t        |      }i }|j                  dd }t        |j                  dd      d	         }|j                  dk(  r7|d
k(  rd}|j                  r$t        j                  d|j                  z  d       |j                  dk(  rRdj                  |j                  |j                        }|j                  r|dj                  |j                        z  }|j                  j                  dd      }|j                  | j                  v r~d|d   v rwt!        t#        j$                  d |d   j                  d      D               }dj'                  |d	         }t)        |      dk(  rdj'                  t+        d|d               nd
}n|j                  }|j                  }|j-                  |xs d
t/        |j0                        xs d
t/        |j2                        xs d
|xs d
t5        |      xs d
d       |j                  | j                  v r|j7                  d      s| j8                  |v r,|j7                  d      r|j                  dd      \  |d<   |d<   |j                  dk(  r|d
k(  r|d   |d<   d
|d<   |j                  dk(  r|d   s|d= nt;        |d         |d<   |j<                  ri }	t?        |j<                        jA                         D ]n  \  }
}|
jC                         | jD                  v r.|j-                  |
jC                         tG        |d	         i       P|	j-                  |
t5        |d	         i       p |	|d<   |r||d<   n|j                  |d<   |d   | j                  v r| j                  |d      |d<   |jI                  dd      s&t        j                  d j                  |             i S |S )!af  Parse an arbitrary database URL.

        Supports the following URL schemas:

        * PostgreSQL: ``postgres[ql]?://`` or ``p[g]?sql://``
        * PostGIS: ``postgis://``
        * MySQL: ``mysql://`` or ``mysql2://``
        * MySQL (GIS): ``mysqlgis://``
        * MySQL Connector Python from Oracle: ``mysql-connector://``
        * SQLite: ``sqlite://``
        * SQLite with SpatiaLite for GeoDjango: ``spatialite://``
        * Oracle: ``oracle://``
        * Microsoft SQL Server: ``mssql://``
        * PyODBC: ``pyodbc://``
        * Amazon Redshift: ``redshift://``
        * LDAP: ``ldap://``

        :param urllib.parse.ParseResult or str url:
            Database URL to parse.
        :param str or None engine:
            If None, the database engine is evaluates from the ``url``.
        :return: Parsed database URL.
        :rtype: dict
        zsqlite://:memory:rP   z:memory:)ENGINENAMEr	   N?r   r   rA   z9SQLite URL contains host component %r, it will be ignored   )
stacklevelrQ   z{scheme}://{hostname})r   hostnamez:{port})port@r   r   c              3   @   K   | ]  }|j                  d d        yw):r	   N)rsplit).0hosts     r   	<genexpr>z$Env.db_url_config.<locals>.<genexpr>  s#        C+s   )r   USERPASSWORDHOSTPORT/r  r   rK   r  OPTIONSr   Fz"Engine not recognized from url: {})%r$   	URL_CLASS
DB_SCHEMESr   r   r   r   r   netlocwarningswarnr*   r   r   r   POSTGRES_FAMILYr   	itertoolszip_longestr   r   filterupdater&   usernamepasswordr!   r   CLOUDSQLr%   queryr   itemsupper_DB_BASE_OPTIONSr   r   )r   r   r   configr   	user_hosthinfor   r   config_optionskr    s               r   r   zEnv.db_url_config  s   4 #s}}-))
 "nnX6& 
 3-C xx|DJJsA.q12::!rz "zz 358ZZ@LMO::*11zz 2 D xx	((chh(77JJ%%c1-	::,,,	"1E%%$-bM$7$7$<E xxa)H7:5zQ388F4q23BD||H88D 	JB .4"$S\\28bNdO)r
 	 

c111dooc6J<<4'DOOC,@-1[[a-@*F6NF6N::!dbj#F^F6NF6N::!&>6N!$VF^!4v99N +113 @1779 4 44MM1779eAaDk":;"))1i!o*>?	@
 !/F9%F8"zzF8(s~~-"~~fX.>?F8zz(E*MM>EEfMNIr"   c                    t        || j                        s|si S t        |      }|j                  | j                  vr$t        dj                  |j                              |j                  j                  d      }t        |      dk(  r|d   }| j                  |j                     |d}|j                  dk(  r*|j                  d|j                  |j                  z   i       |j                  s/|j                  dv r!|j                  dd	|j                  z   i       n|j                  j                  d
      r|j                  r|j                  j                  dd      }nd}|j                  j                  d      D cg c]  }|dz   |z   |j                  z    }}t        |      dk(  r	|d   |d<   n||d<   |j                  ri }t!        |j                        j#                         D ]b  \  }	}
|	j%                         t'        |
d         i}|	j%                         | j(                  v r|j                  |       R|j                  |       d ||d<   |r||d<   |S c c}w )a  Parse an arbitrary cache URL.

        :param urllib.parse.ParseResult or str url:
            Cache URL to parse.
        :param str or None backend:
            If None, the backend is evaluates from the ``url``.
        :return: Parsed cache URL.
        :rtype: dict
        zInvalid cache schema {}r   r	   r   )BACKENDLOCATIONrZ   r  )r\   r]   zunix:r`   cacherA   unixz://r  r  )r$   r  r   r   CACHE_SCHEMESr   r*   r  r   r   r  r   r   r   r   r  r   r  r  r   _CACHE_BASE_OPTIONS)r   r   r   locationr  r   loc	locationsr  r  r    opts               r   r   zEnv.cache_url_config[  s4    #s}}-	3-C::S...&)00<  ::##C(x=A{H ((4 
 ::$MMCJJ1  zzcjj,FFMMGchh.  ZZ""7+||++GR8$'JJ$4$4S$9;   %#-8 ;I ;9~"%.q\z"%.z"99N +113 /1wwy%!+.779 7 77MM#&"))#./ !/F9 'F9);s   I!c           	         i }t        || j                        st        |      n|}|j                  dd }t	        |j                  dd      d         }|j                  |t        |j                        t        |j                        |j                  t        |j                        d       |r||d<   nd|j                  | j                  vrt        d|j                  z        |j                  | j                  v r| j                  |j                     |d<   |j                  d	v rd
|d<   n|j                  dk(  rd
|d<   |j                   ri }t#        |j                         j%                         D ]b  \  }}|j'                         t        |d         i}|j'                         | j(                  v r|j                  |       R|j                  |       d ||d<   |S )a  Parse an arbitrary email URL.

        :param urllib.parse.ParseResult or str url:
            Email URL to parse.
        :param str or None backend:
            If None, the backend is evaluates from the ``url``.
        :return: Parsed email URL.
        :rtype: dict
        r	   Nr   r   r   )EMAIL_FILE_PATHEMAIL_HOST_USEREMAIL_HOST_PASSWORD
EMAIL_HOST
EMAIL_PORTEMAIL_BACKENDzInvalid email schema %s)ri   rj   Trp   rk   rq   r  )r$   r  r   r   r   r   r  r&   r  r  r   r!   r   r   EMAIL_SCHEMESr   r  r   r  r  _EMAIL_BASE_OPTIONS)	r   r   r   r  r   r  r  r    r%  s	            r   r   zEnv.email_url_config  s    #-c3==#Ahsms xx|DJJsA.q12 	#+CLL9#/#=,,#CHH-
 	 &-F?#ZZs000&'@3::'MNNZZ3,,,&)&7&7

&CF?#::..&*F?#ZZ:%&*F?#99N +113 /1wwy)AaD/2779 7 77MM#&"))#./ !/F9r"   c                    i }t        || j                        st        |      n|}|j                  dd }t	        |j                  dd      d         }|j                  | j                  vrt        d|j                  z        | j                  |j                     |d<   i }|j                  ryt        |j                        }d|v r|d   d   j                  d	      |d<   d
|v r| j                  |d
   d   t              |d
<   d|v r| j                  |d   d   t              |d<   |j                  dk(  r|S |j                  dg| j                  z   v rd|v r|d   d   |d<   |j                  d      r|dd }|j                  dk(  r@t!        d|dd z   |fz   dz         |d<   d|v r| j                  |d   d   t              |d<   |S |j                  | j                  v r|j#                  dd      }t%        |      dkD  rdj'                  |dd       }|d   }nd}|d   }t!        d|dd z   |fz   dz         |d<   d|v r| j                  |d   d   t              |d<   ||d<   |S d|z   |d<   |j                  dk(  r3d|v r|d   d   |d<   d|v r>| j                  |d   d   t              |d<   n|j                  dk(  rd|v r|d   d   |d<   |r||d<   |S )a  Parse an arbitrary search URL.

        :param urllib.parse.ParseResult or str url:
            Search URL to parse.
        :param str or None engine:
            If None, the engine is evaluates from the ``url``.
        :return: Parsed search URL.
        :rtype: dict
        r	   Nr   r   r   zInvalid search schema %sr   EXCLUDED_INDEXESr   INCLUDE_SPELLING
BATCH_SIZEry   rv   KWARGSr  r   )http)rA   rA   rA   URLrb   rA   
INDEX_NAMEPATHrw   STORAGE
POST_LIMITrx   FLAGS)r$   r  r   r   r   r   r   SEARCH_SCHEMESr   r  r   r   r   r   ELASTICSEARCH_FAMILYendswithr   r   r   r   )r   r   r   r  r   paramsr   indexs           r   r   zEnv.search_url_config  sI    #-c3==#Ahsms xx|DJJsA.q12::S///&*SZZ7  --cjj9x 99cii(F!V+/0399#> )*!V+-0__-.q1.)* v%'*<(+(|$
 ::!M::&C$<$<<<6!#)(#3A#6x  ==9D::&C!H$w.=F5M F"$'OOF94Ea4H#$Ny!M::111KKQ'E5zA~xxcr
+b	a&C!H$w.=F5M F"$'OOF94Ea4H#$Ny!#(F< Mtv::!F"$*9$5a$8y!v%'*<(+(|$ ZZ8#& "(/!"4w%F8r"   c                 
   |t        j                         }t        j                  j	                  t        j                  j                  |j                  j                  j                        d      }t        j                  j                  |      st        j                  d|       y	 t        |t              r0t        t        |      |      5 }|j!                         }ddd       n|5 }|j!                         }ddd       t        j%                  d|       d }j'                         D ]  }	t)        j*                  d|	      }
|
r|
j-                  d	      |
j-                  d
      }}t)        j*                  d|      }|r|j-                  d	      }t)        j*                  d|      }|r&t)        j.                  d||j-                  d	            }t        |      ||<   |	r|	j1                  d      rt        j3                  d|	        fd} || j4                        }|j7                         D ]  \  }} |||        y# 1 sw Y   KxY w# 1 sw Y   XxY w# t"        $ r t        j                  d|       Y yw xY w)a{  Read a .env file into os.environ.

        If not given a path to a dotenv path, does filthy magic stack
        backtracking to find the dotenv in the same directory as the file that
        called ``read_env``.

        Existing environment variables take precedent and are NOT overwritten
        by the file content. ``overwrite=True`` will force an overwrite of
        existing environment variables.

        Refs:

        * https://wellfire.co/learn/easier-12-factor-django

        :param env_file: The path to the ``.env`` file your application should
            use. If a path is not provided, `read_env` will attempt to import
            the Django settings module from the Django project root.
        :param overwrite: ``overwrite=True`` will force an overwrite of
            existing environment variables.
        :param encoding: The encoding to use when reading the environment file.
        :param \**overrides: Any additional keyword arguments provided directly
            to read_env will be added to the environment. If the key matches an
            existing environment variable, the value will be overridden.
        Nz.envzU%s doesn't exist - if you're not configuring your environment separately, create one.)r   zQ%s not found - if you're not configuring your environment separately, check this.z#Read environment variables from: %sc                 :    | j                  d      }|dv rd|z   S |S )z+Keep escaped newline/tabs in quoted stringsr	   rnt\)group)matchescaped_chars     r   _keep_escaped_format_charactersz5Env.read_env.<locals>._keep_escaped_format_charactersv  s(     ;;q>Lu$l**r"   z$\A(?:export )?([A-Za-z_0-9]+)=(.*)\Zr	   r   z
\A'(.*)'\Zz
\A"(.*)"\Zz\\(.)#zInvalid line: %sc                      r fdS  fdS )zgReturn lambda to set environ.

             Use setdefault unless overwrite is specified.
             c                 <    j                  | t        |      i      S r   )r  r%   r  r    envvals     r   r   z3Env.read_env.<locals>.set_environ.<locals>.<lambda>  s    FMM1c!f+$> r"   c                 :    j                  | t        |            S r   )
setdefaultr%   rK  s     r   r   z3Env.read_env.<locals>.set_environ.<locals>.<lambda>  s     1 1!SV < r"   r3   )rL  	overwrites   `r   set_environz!Env.read_env.<locals>.set_environ  s    
 >><<r"   )sys	_getframeosr   r   dirnamef_backf_codeco_filenameexistsr   infor$   Openableopenr%   readOSErrorr   
splitlinesr   rE  rD  r   r   warningr   r  )r   env_filerO  r   	overridesframefcontentrG  linem1r   r   m2m3rP  setenvr   s     `               r   read_envzEnv.read_env>  s   6 MMOEww|| 3 3 ? ?@H 77>>(+:;CE 	(H-#h-(; 'qffhG' '  'ffhG' 	:HE	  &&( 	9DA4HB88A;SXXmS1((1+CXXmS1&&+J!#!.C!$S	#T__S1148!	9$	= S[[)#//+ 	JC3	c' '' ' 	KK67?A 		sB   *&I  I!I  ,I=I  II  II   JJr   )NFr   ):r,   r0   r1   r2   rS  environr   r(   r   r   r   r  r
  r<  DEFAULT_DATABASE_ENVr
   r  r  DEFAULT_CACHE_ENVr   r   r   r!  DEFAULT_EMAIL_ENVr-  r.  DEFAULT_SEARCH_ENVr;  r  r   r   r   r%   r   r   r   r   r   r   r   r   r   r   dbr   r  r   emailr   r   r   classmethodr   r   r   r   r   rj  )r   r   s   00r   r5   r5   K   s/   : jjGYF@ILO9LMAOa/M)Oo 	 		
 	; 	+ 	, 	3 	: 	$ 	- 	% 	- 	A 	.  	&!J$ $@CJFI'F"M $=>AAGFEC	M +O<%5777;AAAN H "&vU 
#  &  "(&  !' ?  & > "( @ !' E "6 
 #F 
 "6 ?  & 	
 .vd 

 
B-vt 

 E-vt 

 E/ 
 !' D #'e GR 7 7r | || H HT 2 2h ` `D \ \a Ns   E
r5   c                       e Zd ZdZ e       Zy)FileAwareEnva  
    First look for environment variables with ``_FILE`` appended. If found,
    their contents will be read from the file system and used instead.

    Use as a drop-in replacement for the standard ``environ.Env``:

    .. code-block:: python

        python env = environ.FileAwareEnv()

    For example, if a ``SECRET_KEY_FILE`` environment variable was set,
    ``env("SECRET_KEY")`` would find the related variable, returning the file
    contents rather than ever looking up a ``SECRET_KEY`` environment variable.
    N)r,   r0   r1   r2   r   r   r3   r"   r   rt  rt    s      Gr"   rt  c                        e Zd ZdZd Zd Zed        Zd fd	Zd Z	d Z
d Zd	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zed        Z xZS )r   z?Inspired to Django Two-scoops, handling File Paths in Settings.c                 B     | j                   | j                  g|i |S )zCreate new Path based on self.root and provided paths.

        :param paths: List of sub paths
        :param kwargs: required=False
        :rtype: Path
        )r+   __root__r.   pathsr   s      r   r   z	Path.path  s#     t~~dmm>e>v>>r"   c                 ,    t         | |      g|i |S )zOpen a file.

        :param str name: Filename appended to :py:attr:`~root`
        :param \*args: ``*args`` passed to :py:func:`open`
        :param \**kwargs: ``**kwargs`` passed to :py:func:`open`
        :rtype: typing.IO[typing.Any]
        )r[  )r.   nameargsr   s       r   filez	Path.file  s     DJ0000r"   c                     | j                   S )zCurrent directory for this Pathrw  r-   s    r   rootz	Path.root  s     }}r"   c                     t         |           |j                  dd      rt        j                  j                  |      } | j                  |g|i || _        y )Nis_fileF)superr   r   rS  r   rT  _absolute_joinrw  )r.   startry  r   r+   s       r   r   zPath.__init__  sL    ::i'GGOOE*E+++EDEDVDr"   c                 B     | j                   | j                  g|i |S )zRetrieve the absolute path, with appended paths

        :param paths: List of sub path of self.root
        :param kwargs: required=False
        )r  rw  rx  s      r   r   zPath.__call__  s%     #t""4==C5CFCCr"   c                 r    t        |t              r| j                  |j                  k(  S | j                  |k(  S r   r$   r   rw  r.   others     r   __eq__zPath.__eq__  s.    eT"==ENN22}}%%r"   c                 &    | j                  |       S r   )r  r  s     r   __ne__zPath.__ne__  s    ;;u%%%r"   c                     t        |t              st        | j                  |      S t        | j                  |j                        S r   r  r  s     r   __add__zPath.__add__  s2    %&u--DMM5>>22r"   c                 D   t        |t              r| j                  d|z        S t        |t              r?| j                  j                  |      r$t        | j                  j                  |            S t        dj                  t        |       t        |                  )Nz../zkunsupported operand type(s) for -: '{self}' and '{other}' unless value of {self} ends with value of {other}r  )r$   r   r   r%   rw  r=  r   rstripr   r*   r   r  s     r   __sub__zPath.__sub__  s    eS!99UU]++eS!dmm&<&<U&C,,U344@@F$ZtE{ AG A
 	
r"   c                 $    | j                  d      S )Nz..)r   r-   s    r   
__invert__zPath.__invert__  s    yyr"   c                     | j                   }t        |      dkD  r t        j                  j	                  |d      }|j                   j                  |      S )Nr	   rA   )rw  r   rS  r   r   r   )r.   item	base_paths      r   r   zPath.__contains__  s@    MM	y>AY3I}}''	22r"   c                 8    dj                  | j                        S )Nz	<Path:{}>)r*   rw  r-   s    r   r/   zPath.__repr__  s    !!$--00r"   c                     | j                   S r   r  r-   s    r   __str__zPath.__str__  s    }}r"   c                 "    | j                         S r   r  r-   s    r   __unicode__zPath.__unicode__      ||~r"   c                 B     | j                         j                  |i |S r   )r  __getitem__r.   r|  r   s      r   r  zPath.__getitem__
  s     )t||~))4:6::r"   c                 "    | j                         S r   r  r-   s    r   
__fspath__zPath.__fspath__  r  r"   c                 8     t        |       j                  |i |S )z$Proxy method to :py:func:`str.rfind`)r%   rfindr  s      r   r  z
Path.rfind  s    s4y///r"   c                 8     t        |       j                  |i |S )z#Proxy method to :py:func:`str.find`)r%   findr  s      r   r  z	Path.find  s    s4y~~t.v..r"   c                    t         j                  j                  t        j                  j                  | g|       }|j	                  dd      r9t         j                  j                  |      st        dj                  |            |S )NrequiredFzCreate required path: {})rS  r   abspathr   r   rX  r   r*   )basery  r   absolute_paths       r   r  zPath._absolute_join  sf    T(BE(BC::j%(1N&*11-@B Br"   )rA   )r,   r0   r1   r2   r   r}  propertyr  r   r   r  r  r  r  r  r   r/   r  r  r  r  r  r  staticmethodr  __classcell__)r+   s   @r   r   r     s    I?	1  
ED&
&3

31;0/  r"   r   )'r2   r   r  loggingrS  r   rQ  r  urllib.parser   r   r   r   r   r   compatr
   r   r   r   r   fileaware_mappingr   r   ImportErrorpathlibr   r%   rZ  	getLoggerr,   r   r   r!   r&   r(   r5   rt  r   r3   r"   r   <module>r     s   
    	 	 
    0- ?			8	$B
36 6P Pf!3 !$n nO  -,-s   B B! B!