=wgPTddlmZddlZddlZddlZddlZddlmZddlm Z m Z ddl m Z m Z ddlmZmZddlmZddlmZGd d eZGd d eZGd deZGddeZGddeZGddeZdZdZy))with_statementN)Lock)BytesIO memoryview_) BufferFile StructFile)_DEF_INDEX_NAMEEmptyIndexError) random_name)FileLockc eZdZy) StorageErrorN__name__ __module__ __qualname__N/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/filedb/filestore.pyrr)rrc eZdZy) ReadOnlyErrorNrrrrrr-rrrceZdZdZdZdZdZdZdZdZ dZ e dfd Z e ddfd Z dd Zd Zd ZdZdZdZdZdZddZdZdZdZddZy)StorageaEAbstract base class for storage objects. A storage object is a virtual flat filesystem, allowing the creation and retrieval of file-like objects (:class:`~whoosh.filedb.structfile.StructFile` objects). The default implementation (:class:`FileStorage`) uses actual files in a directory. All access to files in Whoosh goes through this object. This allows more different forms of storage (for example, in RAM, in a database, in a single file) to be used transparently. For example, to create a :class:`FileStorage` object:: # Create a storage object st = FileStorage("indexdir") # Create the directory if it doesn't already exist st.create() The :meth:`Storage.create` method makes it slightly easier to swap storage implementations. The ``create()`` method handles set-up of the storage object. For example, ``FileStorage.create()`` creates the directory. A database implementation might create tables. This is designed to let you avoid putting implementation-specific setup code in your application. Fc4t|jSN)iterlistselfs r__iter__zStorage.__iter__PsDIIK  rc&|j|Sr)creaters r __enter__zStorage.__enter__Ss  rc$|jyr)close)r exc_typeexc_valexc_tbs r__exit__zStorage.__exit__Ws  rc|S)aCreates any required implementation-specific resources. For example, a filesystem-based implementation might create a directory, while a database implementation might create tables. For example:: from whoosh.filedb.filestore import FileStorage # Create a storage object st = FileStorage("indexdir") # Create any necessary resources st.create() This method returns ``self`` so you can also say:: st = FileStorage("indexdir").create() Storage implementations should be written so that calling create() a second time on the same storage :return: a :class:`Storage` instance. rrs rr#zStorage.createZs * rcy)aRemoves any implementation-specific resources related to this storage object. For example, a filesystem-based implementation might delete a directory, and a database implementation might drop tables. The arguments are implementation-specific. Nrr argskwargss rdestroyzStorage.destroyqs rNc|jrt|ddl}|jj}|j |||S)aCreates a new index in this storage. >>> from whoosh import fields >>> from whoosh.filedb.filestore import FileStorage >>> schema = fields.Schema(content=fields.TEXT) >>> # Create the storage directory >>> st = FileStorage.create("indexdir") >>> # Create an index in the storage >>> ix = st.create_index(schema) :param schema: the :class:`whoosh.fields.Schema` object to use for the new index. :param indexname: the name of the index within the storage object. You can use this option to store multiple indexes in the same storage. :param indexclass: an optional custom ``Index`` sub-class to use to create the index files. The default is :class:`whoosh.index.FileIndex`. This method will call the ``create`` class method on the given class to create the index. :return: a :class:`whoosh.index.Index` instance. Nr)readonlyr whoosh.indexindex FileIndexr#)r schema indexname indexclasswhooshs r create_indexzStorage.create_index{s>, ==    //J  vy99rcP|ddl}|jj}||||S)aOpens an existing index (created using :meth:`create_index`) in this storage. >>> from whoosh.filedb.filestore import FileStorage >>> st = FileStorage("indexdir") >>> # Open an index in the storage >>> ix = st.open_index() :param indexname: the name of the index within the storage object. You can use this option to store multiple indexes in the same storage. :param schema: if you pass in a :class:`whoosh.fields.Schema` object using this argument, it will override the schema that was stored with the index. :param indexclass: an optional custom ``Index`` sub-class to use to open the index files. The default is :class:`whoosh.index.FileIndex`. This method will instantiate the class with this storage object. :return: a :class:`whoosh.index.Index` instance. Nr)r6r7)r3r4r5)r r7r6r8r9s r open_indexzStorage.open_indexs+*   //J$vCCrc|t} |j|}|j}|j|dkDS#t$rYywxYw)zReturns True if a non-empty index exists in this storage. :param indexname: the name of the index within the storage object. You can use this option to store multiple indexes in the same storage. :rtype: bool F)r r<latest_generationr&r )r r7ixgens r index_existszStorage.index_existssW  'I +B&&(C HHJ8O   s5A A  A ct)zCreates a file with the given name in this storage. :param name: the name for the new file. :return: a :class:`whoosh.filedb.structfile.StructFile` instance. NotImplementedErrorr names r create_filezStorage.create_file "!rct)zOpens a file with the given name in this storage. :param name: the name for the new file. :return: a :class:`whoosh.filedb.structfile.StructFile` instance. rDr rGr.r/s r open_filezStorage.open_filerIrct)zZReturns a list of file names in this storage. :return: a list of strings rDrs rrz Storage.lists "!rct)z}Returns True if the given file exists in this storage. :param name: the name to check. :rtype: bool rDrFs r file_existszStorage.file_existsrIrct)zReturns the last-modified time of the given file in this storage (as a "ctime" UNIX timestamp). :param name: the name to check. :return: a "ctime" number. rDrFs r file_modifiedzStorage.file_modifieds "!rct)zReturns the size (in bytes) of the given file in this storage. :param name: the name to check. :rtype: int rDrFs r file_lengthzStorage.file_lengthrIrct)z\Removes the given file from this storage. :param name: the name to delete. rDrFs r delete_filezStorage.delete_files "!rct)zRenames a file in this storage. :param frm: The current name of the file. :param to: The new name for the file. :param safe: if True, raise an exception if a file with the new name already exists. rD)r frmtosafes r rename_filezStorage.rename_files "!rct)aReturn a named lock object (implementing ``.acquire()`` and ``.release()`` methods). Different storage implementations may use different lock types with different guarantees. For example, the RamStorage object uses Python thread locks, while the FileStorage object uses filesystem-based locks that are valid across different processes. :param name: a name for the lock. :return: a lock-like object. rDrFs rlockz Storage.lock s "!rcy)aCloses any resources opened by this storage object. For some storage implementations this will be a no-op, but for others it is necessary to release locks and/or prevent leaks, so it's a good idea to call it when you're done with a storage object. Nrrs rr&z Storage.closes rcy)zOptimizes the storage object. The meaning and cost of "optimizing" will vary by implementation. For example, a database implementation might run a garbage collection procedure on the underlying database. Nrrs roptimizezStorage.optimize$s rct)aICreates a new storage object for temporary files. You can call :meth:`Storage.destroy` on the new storage when you're finished with it. :param name: a name for the new storage. This may be optional or required depending on the storage implementation. :rtype: :class:`Storage` rDrFs r temp_storagezStorage.temp_storage,s "!rrF)rrr__doc__r2 supports_mmapr!r$r*r#r0r r:r<rBrHrLrrOrQrSrUrZr\r&r_rarrrrr3s2HM!. .=::$34DD4&""""""" " "   "rrcleZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZddZy)OverlayStoragezOverlays two storage objects. Reads are processed from the first if it has the named file, otherwise the second. Writes always go to the second. c ||_||_yr)ab)r rhris r__init__zOverlayStorage.__init__>src<|jj|i|yr)rir:r-s rr:zOverlayStorage.create_indexBsT,V,rc<|jj|i|yr)rhr<r-s rr<zOverlayStorage.open_indexEs4*6*rc:|jj|i|Sr)rirHr-s rrHzOverlayStorage.create_fileHs!tvv!!42622rc|jj|r |jj|g|i|S|jj|g|i|Sr)rhrOrLrirKs rrLzOverlayStorage.open_fileKsV 66  d ##466##D:4:6: :#466##D:4:6: :rctt|jjt|jjzSr)rsetrhrirs rrzOverlayStorage.listQs0C &TVV[[]);;< 66  d #66''- -66''- -rc|jj|r|jj|S|jj|Sr)rhrOrSrirFs rrSzOverlayStorage.file_length]s> 66  d #66%%d+ +66%%d+ +rc8|jj|Sr)rirUrFs rrUzOverlayStorage.delete_filecsvv!!$''rctrrDr-s rrZzOverlayStorage.rename_filefs!!rc8|jj|Sr)rir\rFs rr\zOverlayStorage.lockisvv{{4  rcl|jj|jjyr)rhr&rirs rr&zOverlayStorage.closels    rcl|jj|jjyr)rhr_rirs rr_zOverlayStorage.optimizeps  rNc:|jj|S)N)rG)rirarFs rrazOverlayStorage.temp_storagetsvv"""--rr)rrrrcrjr:r<rHrLrrOrQrSrUrZr\r&r_rarrrrfrf9sS-+3; =D. , ("!.rrfc~eZdZdZdZddZdZdZdZddZ dZ d Z dd Z d Z d Zd ZdZdZddZdZddZy) FileStorageaSStorage object that stores the index as files in a directory on disk. Prior to version 3, the initializer would raise an IOError if the directory did not exist. As of version 3, the object does not check if the directory exists at initialization. This change is to support using the :meth:`FileStorage.create` method. TcJ||_||_||_||_i|_y)a :param path: a path to a directory. :param supports_mmap: if True (the default), use the ``mmap`` module to open memory mapped files. You can open the storage object with ``supports_mmap=False`` to force Whoosh to open files normally instead of with ``mmap``. :param readonly: If ``True``, the object will raise an exception if you attempt to create or rename a file. N)folderrdr2_debuglocks)r pathrdr2debugs rrjzFileStorage.__init__s( *    rcN|jjd|jdS)N()) __class__rr}rs r__repr__zFileStorage.__repr__s>>22DKK@@rctjj|j} tj|tjj|s%td|z}tj|_||S#t $r8t jd}|jtjk7rYwxYw)aCreates this storage object's directory path using ``os.makedirs`` if it doesn't already exist. >>> from whoosh.filedb.filestore import FileStorage >>> st = FileStorage("indexdir") >>> st.create() This method returns ``self``, you can say:: st = FileStorage("indexdir").create() Note that you can simply create handle the creation of the directory yourself and open the storage object using the initializer:: dirname = "indexdir" os.mkdir(dirname) st = FileStorage(dirname) However, using the ``create()`` method allows you to potentially swap in other storage implementations more easily. :return: a :class:`Storage` instance. z%r is not a directory) osrabspathr}makedirsOSErrorsysexc_infoerrnoEEXISTisdirIOErrorENOTDIR)r dirpathes rr#zFileStorage.creates2''//$++.  KK ww}}W%/'9:AmmAGG   q!Aww%,,&'  sB>CCc|j tj|jy#t$r9t j d}|jtjk(rYy|wxYw)zRemoves any files in this storage object and then removes the storage object's directory. What happens if any of the files or the directory are in use depends on the underlying platform. rN) cleanrrmdirr}rrrrENOENT)r rs rr0zFileStorage.destroysY   HHT[[ !  q!Aww%,,&  s2=A41A4c |jrt|j|}|rtjtj ztj z}ttdr|tjz}tj||}tj||}n t||}t|fd|i|} | S)aeCreates a file with the given name in this storage. :param name: the name for the new file. :param excl: if True, try to open the file in "exclusive" mode. :param mode: the mode flags with which to open the file. The default is ``"wb"``. :return: a :class:`whoosh.filedb.structfile.StructFile` instance. O_BINARYrG) r2r_fpathrO_CREATO_EXCLO_RDWRhasattrropenfdopenr) r rGexclmoder/rflagsfdfileobjfs rrHzFileStorage.create_files == {{4  JJ*RYY6Er:&$u%BiiD)G4&G w 4T 4V 4rc Ttt|j|dfd|i|}|S)aCOpens an existing file in this storage. :param name: the name of the file to open. :param kwargs: additional keyword arguments are passed through to the :class:`~whoosh.filedb.structfile.StructFile` initializer. :return: a :class:`whoosh.filedb.structfile.StructFile` instance. rbrG)rrr)r rGr/rs rrLzFileStorage.open_files- tDKK-t4 J4 J6 Jrctjjtjj|j|Sr)rrrjoinr})r fnames rrzFileStorage._fpaths(wwrww||DKK?@@rc|jrt|j}|j}|D]6} t j tj j||8y#t$r|sYHwxYwr) r2rr}rrremoverrr)r ignorerfilesrs rrzFileStorage.cleansn == {{  E  "'',,tU34   s3A++ A:9A:cj tj|j}|S#t$rg}Y|SwxYwr)rlistdirr}r)r rs rrzFileStorage.list s; JJt{{+E  E  s # 22c^tjj|j|Sr)rrexistsrrFs rrOzFileStorage.file_existssww~~dkk$/00rc^tjj|j|Sr)rrgetmtimerrFs rrQzFileStorage.file_modifieds ww D 122rc^tjj|j|Sr)rrgetsizerrFs rrSzFileStorage.file_lengthswwt{{4011rcp|jrttj|j |yr)r2rrrrrFs rrUzFileStorage.delete_files$ ==  $++d#$rcT|jrttjj |j |r4|rt d|ztj|j |tj|j ||j |yNzFile %r exists) r2rrrrr NameErrorrrename)r oldnamenewnamerYs rrZzFileStorage.rename_file"sq ==  77>>$++g. / 07 :;; $++g./ $++g& G(<=rc6t|j|Sr)r rrFs rr\zFileStorage.lock-s D)**rNc|xs dtz}tjj|j|}t |}|j SNz%s.tmp)r rrrr}r{r#)r rGr tempstores rrazFileStorage.temp_storage0sD/x+-/ww||DKK.% !!r)TFF)Fwbrbr)rrrrcrdrjrr#r0rHrLrrrrOrQrSrUrZr\rarrrr{r{xsaM"A*X$4 A 132% >+"rr{cleZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z dd Zd ZdZdZddZy) RamStoragez3Storage object that keeps the index in memory. Fc.i|_i|_d|_y)N)rrr}rs rrjzRamStorage.__init__=s   rc |`|`yr)rrrs rr0zRamStorage.destroyBs J JrcHt|jjSr)rrkeysrs rrzRamStorage.listFsDJJOO%&&rci|_yrrrs rrzRamStorage.cleanIs  rcHtfdjDS)Nc3@K|]}j|ywr)rS).0rr s r z(RamStorage.total_size..Ms<14##A&rrFs rrQzRamStorage.file_modifiedWsrcP||jvr t||j|=yrrrrFs rrUzRamStorage.delete_fileZs$ tzz !D/ ! JJt rc||jvr t||r||jvrtd|z|j|}|j|=||j|<yrr)r rGrrYcontents rrZzRamStorage.rename_file_s_ tzz !D/ ! Gtzz),w67 7**T" JJt % 7rc Bfd}tt|}|S)NcT|jjj<yr)filegetvaluer)sfilerGr s r onclose_fnz*RamStorage.create_file..onclose_fnjs$zz224DJJt r)rGonclose)rr)r rGr/rrs`` rrHzRamStorage.create_fileis 5 wytZ @rc ||jvr t|t|j|}t|fd|i|S)NrG)rrrr)r rGr/bufs rrLzRamStorage.open_fileos@ tzz !D/ !$**T*+#3D3F33rcj||jvrt|j|<|j|Sr)rrrFs rr\zRamStorage.lockus- tzz !#vDJJt zz$rNctj}|xs dtz}tjj ||}t |}|jSr)tempfile gettempdirr rrrr{r#)r rGtdirrrs rrazRamStorage.temp_storagezsN""$/x+-/ww||D$'% !!rrbr)rrrrcrdrjr0rrrrOrSrQrUrZrHrLr\rarrrrr7sTM '="%  & 4  "rrcddlm}|jD]?}|j|5}|j |5}|||ddddddAy#1swYxYw#1swYXxYw)zxCopies the files from the source storage object to the destination storage object using ``shutil.copyfileobj``. r) copyfileobjN)shutilrrrLrH) sourcestore deststorerrGsourcedests r copy_storagersx#  "*  " "4 ( *F&&t, *FD) * * ** * * * *s"A& AA&A# A&&A/ c2t}t|||S)zgCopies the given FileStorage object into a new RamStorage object. :rtype: :class:`RamStorage` )rr)storagerams r copy_to_ramrs ,C# Jr) __future__rrrrr threadingr whoosh.compatrrwhoosh.filedb.structfilerrr3r r whoosh.utilr whoosh.util.filelockr Exceptionrrobjectrrfr{rrrrrrrs~8&.;9#)  9  L C"fC"L<.W<.~|"'|"~H"H"V *r