vortexpy 4.0.23__py3-none-any.whl

vortex/storage/TupleStorageSqlite.py

@@ -0,0 +1,359 @@
+import logging
+import sqlite3
+from collections import namedtuple
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from typing import Union
+
+import pytz
+from twisted.internet import defer
+from twisted.internet.defer import Deferred
+from twisted.internet.defer import DeferredSemaphore
+from twisted.internet.defer import inlineCallbacks
+
+from vortex.DeferUtil import deferToThreadWrapWithLogger
+from vortex.Payload import Payload
+from vortex.Tuple import Tuple
+from vortex.TupleSelector import TupleSelector
+
+# ------------------------------------------------------------------------------
+
+CREATE_TABLE_SQL = """CREATE TABLE IF NOT EXISTS tuples
+     (
+        tupleSelector TEXT,
+        dateTime REAL,
+        payload TEXT,
+        PRIMARY KEY (tupleSelector)
+     )"""
+
+DROP_TABLE_SQL = """DROP TABLE IF NOT EXISTS tuples"""
+
+DELETE_BY_SELECTOR_SQL = """DELETE
+                 FROM tuples
+                 WHERE tupleSelector = ?"""
+
+DELETE_BY_DATE_SQL = """DELETE
+                 FROM tuples
+                 WHERE dateTime < ?"""
+
+INSERT_SQL = """INSERT OR REPLACE INTO tuples
+                 (tupleSelector, dateTime, payload)
+                 VALUES (?, ?, ?)"""
+
+SELECT_SQL = """SELECT payload
+                 FROM tuples
+                 WHERE tupleSelector = ?"""
+
+SELECT_ALL_PAYLOADS_SQL = """SELECT payload from tuples"""
+
+# ------------------------------------------------------------------------------
+
+TupleStorageBatchSaveArguments = namedtuple(
+    "TupleStorageBatchSaveArguments", ["tupleSelector", "encodedPayload"]
+)
+
+
+# ------------------------------------------------------------------------------
+
+
+class TupleStorageSqlite:
+    TRANSACTIONS_BEFORE_VACUUM = 50
+
+    def __init__(self, databaseDirectory: Path, databaseName: str):
+        databaseDirectory = databaseDirectory.expanduser()
+        self._databaseDirectory = databaseDirectory
+        self._databaseName = databaseName.lower().replace(".sqlite", "")
+        self._databasePath = (
+            databaseDirectory / f"{databaseName.lower()}.sqlite"
+        )
+
+        self._logger = logging.getLogger(f"{__name__} DB={self._databaseName}")
+
+        self._isDbOpen = False
+        self._transactionSemaphore = DeferredSemaphore(tokens=1)
+
+        self._transactionsSinceVacuum = 0
+
+    @property
+    def databasePath(self) -> Path:
+        return self._databasePath
+
+    def open(self) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(self._openBlocking)
+        )
+
+    def _openBlocking(self):
+        self._closeBlocking()
+        self._isDbOpen = False
+        try:
+            with sqlite3.connect(self._databasePath) as conn:
+                conn.execute(CREATE_TABLE_SQL)
+                conn.commit()
+            self._isDbOpen = True
+        except sqlite3.Error as e:
+            self._isDbOpen = False
+            raise
+
+    def isOpen(self) -> Deferred:
+        return defer.succeed(self._isDbOpen)
+
+    def _isOpenBlocking(self) -> bool:
+        return self._isDbOpen
+
+    def close(self) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(self._closeBlocking)
+        )
+
+    def _closeBlocking(self):
+        self._isDbOpen = False
+
+    def truncateStorage(self) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(
+                self._truncateStorageBlocking
+            )
+        )
+
+    def _truncateStorageBlocking(self):
+        self._closeBlocking()
+        self._databasePath.unlink(missing_ok=True)
+        self._openBlocking()
+
+    def snapshotToPath(self, path: Path) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(
+                self._snapshotToPathBlocking
+            ),
+            path=path,
+        )
+
+    def _snapshotToPathBlocking(self, path: Path):
+        assert self._isOpenBlocking(), "Database is not open"
+        path.unlink(missing_ok=True)
+        self._db.execute("VACUUM main INTO '%s'" % path)
+
+    def loadTuplesAndAggregateAllTuples(self, batchSize=250) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(
+                self._loadTuplesAndAggregateAllTuplesBlocking
+            ),
+            batchSize=batchSize,
+        )
+
+    def _loadTuplesAndAggregateAllTuplesBlocking(
+        self, batchSize: int
+    ) -> list[Tuple]:
+        startTime = datetime.now(pytz.UTC)
+
+        tuples = []
+
+        with sqlite3.connect(self._databasePath) as conn:
+            # Perform the transaction
+            cur = conn.cursor()
+            cur.execute(SELECT_ALL_PAYLOADS_SQL)
+            while True:
+                fetchStartTime = datetime.now(pytz.UTC)
+                rows = cur.fetchmany(batchSize)
+                if not rows:
+                    break
+                newTuples = []
+                for row in rows:
+                    newTuples.extend(
+                        Payload().fromEncodedPayload(row[0]).tuples
+                    )
+
+                tuples.extend(newTuples)
+
+                self._logger.debug(
+                    "PROGRESS loadTuplesAndAggregateAllTuples"
+                    " took %s for %s rows, %s tuples, total tuples = %s",
+                    datetime.now(pytz.UTC) - fetchStartTime,
+                    len(rows),
+                    len(newTuples),
+                    len(tuples),
+                )
+
+        self._logger.debug(
+            "FINISHED loadTuplesAndAggregateAllTuples took %s for %s tuples",
+            datetime.now(pytz.UTC) - startTime,
+            len(tuples),
+        )
+
+        return tuples
+
+    @inlineCallbacks
+    def loadTuples(self, tupleSelector: TupleSelector) -> Deferred:
+        startTime = datetime.now(pytz.UTC)
+
+        encodedPayload = yield self.loadTuplesEncoded(tupleSelector)
+        if not encodedPayload:
+            return []
+
+        payload = yield Payload().fromEncodedPayloadDefer(encodedPayload)
+
+        self._logger.debug(
+            "loadTuples took %s for %s tuples for %s",
+            datetime.now(pytz.UTC) - startTime,
+            len(payload.tuples),
+            tupleSelector,
+        )
+
+        return payload.tuples
+
+    def loadTuplesEncoded(self, tupleSelector: TupleSelector) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(
+                self._loadTuplesEncodedBlocking
+            ),
+            tupleSelector=tupleSelector,
+        )
+
+    def _loadTuplesEncodedBlocking(
+        self, tupleSelector: Union[TupleSelector, str]
+    ) -> Optional[bytes]:
+        tupleSelectorStr = (
+            tupleSelector
+            if isinstance(tupleSelector, str)
+            else tupleSelector.toJsonStr()
+        )
+
+        # Make sure the database is open
+        assert self._isOpenBlocking(), "Database is not open"
+
+        with sqlite3.connect(self._databasePath) as conn:
+            # Perform the transaction
+            cur = conn.cursor()
+            cur.execute(SELECT_SQL, (tupleSelectorStr,))
+            rows = cur.fetchall()
+        return rows[0][0] if rows else None
+
+    @inlineCallbacks
+    def saveTuples(
+        self, tupleSelector: TupleSelector, tuples: list[Tuple]
+    ) -> Deferred:
+        startTime = datetime.now(pytz.UTC)
+
+        encodedPayload = yield Payload(tuples=tuples).toEncodedPayloadDefer()
+        yield self.saveTuplesEncoded(tupleSelector, encodedPayload)
+
+        self._logger.debug(
+            "saveTuples took %s for %s tuples for %s",
+            datetime.now(pytz.UTC) - startTime,
+            len(tuples),
+            tupleSelector,
+        )
+
+    @inlineCallbacks
+    def saveTuplesEncoded(
+        self, tupleSelector: Union[TupleSelector, str], encodedPayload: bytes
+    ) -> Deferred:
+        tupleSelectorStr = (
+            tupleSelector
+            if isinstance(tupleSelector, str)
+            else tupleSelector.toJsonStr()
+        )
+
+        dateInt = round(datetime.now(pytz.UTC).timestamp() * 1000)
+        params = [(tupleSelectorStr, dateInt, encodedPayload)]
+        yield self._transaction(INSERT_SQL, params)
+
+    @inlineCallbacks
+    def batchSaveTuplesEncoded(
+        self, data: list[TupleStorageBatchSaveArguments]
+    ) -> Deferred:
+        if not data:
+            return
+
+        dateInt = round(datetime.now(pytz.UTC).timestamp() * 1000)
+        params = [
+            (
+                (
+                    d.tupleSelector
+                    if isinstance(d.tupleSelector, str)
+                    else d.tupleSelector.toJsonStr()
+                ),
+                dateInt,
+                d.encodedPayload,
+            )
+            for d in data
+        ]
+        yield self._transaction(INSERT_SQL, params)
+
+    @inlineCallbacks
+    def batchDeleteTuples(
+        self, tupleSelectors: list[Union[TupleSelector, str]]
+    ) -> Deferred:
+        params = [
+            (
+                (
+                    tupleSelector
+                    if isinstance(tupleSelector, str)
+                    else tupleSelector.toJsonStr()
+                ),  # This comma creates the tuple required for parameters
+            )
+            for tupleSelector in tupleSelectors
+        ]
+
+        yield self._transaction(DELETE_BY_SELECTOR_SQL, params)
+
+    @inlineCallbacks
+    def deleteTuples(
+        self, tupleSelector: Union[TupleSelector, str]
+    ) -> Deferred:
+        tupleSelectorStr = (
+            tupleSelector
+            if isinstance(tupleSelector, str)
+            else tupleSelector.toJsonStr()
+        )
+
+        yield self._transaction(DELETE_BY_SELECTOR_SQL, [(tupleSelectorStr,)])
+
+    @inlineCallbacks
+    def deleteOldTuples(self, deleteDataBeforeDate: datetime) -> Deferred:
+        dateInt = round(
+            deleteDataBeforeDate.astimezone(pytz.UTC).timestamp() * 1000
+        )
+
+        yield self._transaction(DELETE_BY_DATE_SQL, [(dateInt,)])
+
+    def _transaction(
+        self, sql: str, params: Optional[list[tuple]] = None
+    ) -> Deferred:
+        return self._transactionSemaphore.run(
+            deferToThreadWrapWithLogger(self._logger)(
+                self._transactionBlocking
+            ),
+            sql=sql,
+            params=params,
+        )
+
+    def _transactionBlocking(
+        self, sql: str, params: Optional[list[tuple]] = None
+    ):
+        if not params:
+            params = []
+
+        # Make sure the input data is correct.
+        assert isinstance(params, list), "Parameters should be a list of tuples"
+        assert not len(params) or isinstance(
+            params[0], tuple
+        ), "Parameters should be a list of tuples"
+
+        # Make sure the database is open
+        assert self._isOpenBlocking(), "Database is not open"
+
+        # Perform the transaction
+
+        with sqlite3.connect(self._databasePath) as conn:
+            cur = conn.cursor()
+            cur.executemany(sql, params)
+            conn.commit()
+
+            self._transactionsSinceVacuum += 1
+
+            if self._transactionsSinceVacuum > self.TRANSACTIONS_BEFORE_VACUUM:
+                conn.execute("VACUUM")
+                self._transactionsSinceVacuum = 0

vortexpy-4.0.23.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vortexpy-4.0.23.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.2
+Name: vortexpy
+Version: 4.0.23
+Summary: Synertys observable, routable, data serialisation and transport code.
+Author-email: Synerty <contact@synerty.com>
+License: MIT License
+        
+        Copyright (c) 2016 
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/Synerty/vortexpy
+Project-URL: Download, https://github.com/Synerty/vortexpy/tarball/3.4.6
+Keywords: vortex,observable,http,compressed,synerty
+Classifier: Programming Language :: Python :: 3.5
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=2.0
+Requires-Dist: GeoAlchemy2
+Requires-Dist: txwebsocket>=1.1.0
+Requires-Dist: autobahn[twisted]
+Requires-Dist: vcversioner
+Requires-Dist: six
+Requires-Dist: pytz
+Requires-Dist: reactivex>=4.0.4
+Requires-Dist: ddt>=1.6.0
+Requires-Dist: psutil
+Requires-Dist: txhttputil>=1.2.0

vortexpy-4.0.23.dist-info/RECORD

@@ -0,0 +1,87 @@
+vortex/DataWrapTuple.py,sha256=l3FvZv8i2abVuR-Jmnhl1cXtdr5A416xGEhMPjETmVk,551
+vortex/DeferUtil.py,sha256=ehuONrO74YPSm5WXLhSx_1zrbbebEXHBIwypEEfx8iI,6169
+vortex/Jsonable.py,sha256=_bUm6oxZWjyb_VDMmDYBWby7Jrb5l3WlX3im3oS11FA,9564
+vortex/Payload.py,sha256=Mf3q9Zvj1klSGMuXCPzbd0QiST8r9D9nqSiHobdHImI,3674
+vortex/PayloadEndpoint.py,sha256=UgDvqXYTj9Zs8GGHJGrcKhoxYhmmosz8sKLnefu8lQA,6602
+vortex/PayloadEndpointTest.py,sha256=IRic7ITwGfCGohdxDF3lvurfDMy-HgL9M4ZGq6uJVIY,4636
+vortex/PayloadEnvelope.py,sha256=DrYoerNBkOnYpUa1TpVERQkP4V6adGkREzyCd6CNo6U,4912
+vortex/PayloadFilterKeys.py,sha256=wC0ARGbnwGTZA-bwWq0aDdK1fmNRnUYCgcKfZUQXRCQ,319
+vortex/PayloadIO.py,sha256=4_RzfQa3H44hLIfqkosIvcrscDKydunCXjQOvBHfTBk,4500
+vortex/PayloadPriority.py,sha256=4WyH0TpwfX607K3JfrfgQ4iGJ2zBGVbw96Yfcivo6Ds,213
+vortex/PayloadResponse.py,sha256=Lxa4TtiQ5MSfZCOeM964E_nKOLRDPGNebbKt1u5Y_qc,5356
+vortex/PayloadResponseTest.py,sha256=bmuqiHv-qRU6YD2RCNtNFNc9TvzZ4SJ3WD4e_O7aft0,1290
+vortex/PayloadTest.py,sha256=EIi2YJcqfUBjbdYKEIPDlpmqggJrocdjCl3aE8UlzAU,4360
+vortex/PerformTestActionTuple.py,sha256=xnCaGoGO9qFD4SP3E7S8uORRBTttqORppRSmoF3QFgs,713
+vortex/SerialiseUtil.py,sha256=M_R4k-FaGF-DyQXvwYJS_XAo21st0SphVs_zi5rhneM,6480
+vortex/TestTuple.py,sha256=k5lauJ0vraWu5DIFqSWFrNEq5uOGuIS9XNnmYWmOPQw,1597
+vortex/Tuple.py,sha256=WzVXtzfW0xTmu7u1dSN4yYE_rzZusdRu5FDZwLxsOLw,30566
+vortex/TupleAction.py,sha256=Fr65HDi_8iHPdshkFxNZ4V3u0-xvZqHRJt_2a5KSiCA,1956
+vortex/TupleActionVortex.py,sha256=uNVHvqWyLLJkACyfBixkduRjs3qudGBp7PL3-1T9D8U,187
+vortex/TupleDataForTest.py,sha256=cH9ebUHIppIADWxbL9_Ky2c1ZTjDf30Hyb7vCQas4as,606
+vortex/TuplePerfTest.py,sha256=oOlAAgOiiFrNJIHlCuAYa2wxXLPu7Dg7A-p702uxn7Y,1623
+vortex/TuplePolymorphicTupleTypeFieldArgTest.py,sha256=TaRtSaDsbXu4rGP29K14m2F4BVdlR8GJ6T3Ydvvj2Xg,2207
+vortex/TupleRestfulTest.py,sha256=KlBRd_t7ornbWjSu3GOCZScJ55eGb_nRcII1COmlOoU,3978
+vortex/TupleSelector.py,sha256=55h0EIEJqLYaJn1ZvOT0WrV_mKF4ETW2DjgvDwMiqyw,2997
+vortex/TupleTest.py,sha256=D9488Xpz_AqCZ3EIFpV3hnKEjqaym2gpgV3fDbrPMqA,3866
+vortex/VortexABC.py,sha256=Vr2FZaPt7QLaP3W4INxNrrhKZRYvN9ptacDsBhSs9YA,1350
+vortex/VortexClientHttp.py,sha256=--Cv0nMu-yV1pmHh4M_U3NKPQgnFa-uI9ZWUIiVMSFI,8710
+vortex/VortexClientHttpTest.py,sha256=r1-qBx0nfTc6y9am3POFeI2cTofHetWueOPGqEFTe3U,1790
+vortex/VortexClientTcp.py,sha256=KAKvusE8qsgjPBlSB13F-c1dZNdJAWACjpYBXm5HuZo,10800
+vortex/VortexClientWebsocketFactory.py,sha256=6cr5GQc8qedDxiGHl6cig1YjY4XAScNcMyOjJeL9Hlc,11752
+vortex/VortexConnectionABC.py,sha256=2qnu5Rv0UWyqkndMbdEUXgAbTB9R3DaEtOcdBe6-ov4,2057
+vortex/VortexFactory.py,sha256=Gf2_loIlNR0iYhn6b-wB6q42L0lxDX1E80z8z0WjAic,33086
+vortex/VortexPayloadProtocol.py,sha256=HmiqVmXjICddqT0uk5D6emyTkfORixtuV2Y-NNEYq6s,5586
+vortex/VortexServer.py,sha256=gp5KqHph5tg70LJaTeiOtY4oF5SCHnuU5Zpm3d5KiVw,11607
+vortex/VortexServerConnection.py,sha256=TpU4MnVlHKiu4UG5jW8EHMuwYU3QsM98AH9e_endc8I,3758
+vortex/VortexServerHttpResource.py,sha256=0PNE3C7hjTNdTIA3kkmb6rDEZ4c-EO2yNbUmNXik5Lw,5834
+vortex/VortexServerTcp.py,sha256=7p2Bwk-akiPofZVtYRxKvQcxDy2UpbeRV1xm-KfaDaw,3081
+vortex/VortexServerWebsocket.py,sha256=yp7CwvYg9YdqFzqXqTjyR4CozRUPpjJvn4FHmEQUiAc,9335
+vortex/VortexTcpMemoryLeakPayloadTest.py,sha256=88mliRzSCxbytMyH-6fhXVbQ1hHVFuvu_8er0PuYs4E,19710
+vortex/VortexTcpMemoryLeakRawTest.py,sha256=6mcIsQyA8eMkx6LLn_8ORxBYejAb-JfeeFktiLysq-M,2327
+vortex/VortexTest.py,sha256=-4zGv5PlteklFdI26VMtsN69xmkc_Grijxyz7zJZiw0,548
+vortex/VortexUtil.py,sha256=FI_rmzGR2EN3ogmJZtqNhPeLIKc_OHGY-t09V5zyzHo,9770
+vortex/VortexWritePushProducer.py,sha256=RlQvywwW8FoEzYPR0QQSyY7SZYaHaSewjGNGSEmqlXM,10495
+vortex/__init__.py,sha256=bFGstg784xtzBRw3ie2STPvzLM_fEaqBg6WPXHFH6_w,195
+vortex/data_loader/TupleDataLiveLockManager.py,sha256=TjZz89VaAtqOc_JT8eW7BP4iNW4x2SCE_XdOlGahbvk,12887
+vortex/data_loader/TupleDataLoader.py,sha256=32EvaK61A_mfwMYO_TNKEREYV4HdA-UbQPP_Ie-QNIo,11548
+vortex/data_loader/TupleDataLoaderDelegate.py,sha256=YhoNIrQvC2S399aNXhwFhQPgfJntCM30KWrEA1xejrE,2609
+vortex/data_loader/TupleDataLoaderTupleABC.py,sha256=qYm-nFbGubXMFm1PBdJ5zO3tWYfyUrc3bzBIKTUO_0U,177
+vortex/data_loader/TupleDataLoaderTuples.py,sha256=PH4yR5-uZXPWrPNgfxguhw8u25lyvL4K_ZJblAkU9hg,1696
+vortex/data_loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/event_bus/TupleChangeEventABC.py,sha256=x79SH_dLrR3Al4Sbeb5XcPfJz5oLkBIkHH9EK0fncRc,325
+vortex/event_bus/TupleChangeEventBus.py,sha256=-0X4fHEYd6VPV67-gcvSqTS9V8dW0O6tWtafcZjsxGg,6122
+vortex/event_bus/TupleChangeEventBusObserverABC.py,sha256=GNpIMyO81AYIOC1zco61pLVKWUenSse9__VtTdrBbFE,358
+vortex/event_bus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/handler/TupleActionProcessor.py,sha256=5K6nbl-zbMMIwZpbTdVSR1jKWgEQHECfQ4-a-3BrJu0,8353
+vortex/handler/TupleActionProcessorProxy.py,sha256=9CIp0WfTK6Cdadj8Eioy2nldzi6arILZA6k08cPRdO0,7290
+vortex/handler/TupleActionProcessorTestHandler.py,sha256=n7DIOF5-Bp9RSa1zNDB2_wfBA1qtsOQ5HDXIlE3ACxc,933
+vortex/handler/TupleDataActionClient.py,sha256=eEOsXlilpgYUjMKBhXMJEXu3eAg2R7hZrMQILXeylGU,2112
+vortex/handler/TupleDataObservableCache.py,sha256=jfmnF_xAN-JaT1_1jJGDFrBTqKwjSbOi614qL6CR9as,6202
+vortex/handler/TupleDataObservableHandler.py,sha256=ZCRuzdhTjzO2yLe3pM3i7nNXAN34JIql2FLWLBHRHiA,12671
+vortex/handler/TupleDataObservableProxyHandler.py,sha256=PPqNb-73FkCXbksEV2Vgqvl5LRbIdE2FxXNxjrhHnc8,11648
+vortex/handler/TupleDataObservableTestHandler.py,sha256=HoVH30ZelMc-108KZSVLm70FdwlKNUoiOBfOC9sQAcc,1969
+vortex/handler/TupleDataObserverClient.py,sha256=2JgQOP_oND11mj4n87MiFHe51PVdqZI3cwn7b_8xmUs,5552
+vortex/handler/VortexJSTupleLoaderTestHandler.py,sha256=cgLrRWokYgXhYiwF2L8E5fTYQRUstXHcdZsNZh5nDSk,1438
+vortex/handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/restful/GzippedDataHttpClient.py,sha256=NDvgGuraZ8LVHEYwnd28H_z-TL0P9sAGrD7VwhgE-uI,5153
+vortex/restful/GzippedDataHttpClientTest.py,sha256=S1AtPBXkTvqGfgiw-iIhy3urexlRyPUUqMj41GGxurs,3304
+vortex/restful/GzippedPayloadHttpClient.py,sha256=vPwOHep0dHuywOHAJ6_sPLx7KAOfSYEmxHh7MkwrpJU,5636
+vortex/restful/RestfulHttpClient.py,sha256=Vyr8yM4YZg4YviAiFWu5Vw05flJUPDfo8gXat7MtpPE,3007
+vortex/restful/RestfulHttpClientTest.py,sha256=rm7BXbheYqwUDI_OKIVWmJkQOliNTupFUGh6F1DVfFc,1662
+vortex/restful/RestfulResource.py,sha256=2-BRAgO6jd6_DgI9dZBkhejO6TkXgTQ3DiYGc625eFo,4958
+vortex/restful/RestfulResourceTest.py,sha256=nxDrFFgAqYlz0k96XKlBcpnFqbbtNRYrexdWpwv8bd8,3292
+vortex/restful/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/rpc/RPC.py,sha256=yYLXXPgtSzk2nxZghF_kDsMCjW7AA1drId9dX70BQZw,13497
+vortex/rpc/RPCTest.py,sha256=kfTsDRsqsoXPHLSqr4Qohl3zKYM3_6k43o6Us0k_zgA,387
+vortex/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/sqla_orm/OrmCrudHandler.py,sha256=2Z2ys4ByCj2Qs3Fww30RlqbKTseIuADfMcIpMo-oFgo,13698
+vortex/sqla_orm/TupleProviderForDb.py,sha256=oWrt85TdWalZH3e1xF_MIhPVaBi6uv1QKfXIL8mYbIg,1414
+vortex/sqla_orm/VortexTupleJson.py,sha256=1Vjs12Hc2hFArHdpHK1p-EIVw2Xjp5NIYd0HaRlVZwc,636
+vortex/sqla_orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex/storage/TupleStorageSqlite.py,sha256=kCiwXzD_EMjiatH-OKHC76BhcIsBFfJUOMr8kcXxh8w,11237
+vortex/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortexpy-4.0.23.dist-info/LICENSE,sha256=pEbyGaq-NmeFBES71fEbfpMYibTV2_O8B0_gDyXxEkw,1057
+vortexpy-4.0.23.dist-info/METADATA,sha256=qa7_ThLdnFUULG2X2LgYBAWCd7X4gjxMczIBmuUaKcU,1971
+vortexpy-4.0.23.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+vortexpy-4.0.23.dist-info/top_level.txt,sha256=3xfbSD7kw8xKl0jk4GNHsOPKbhubstfWHPl6bxHciRQ,7
+vortexpy-4.0.23.dist-info/RECORD,,

vortexpy-4.0.23.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vortexpy-4.0.23.dist-info/top_level.txt

@@ -0,0 +1 @@
+vortex