oracle-driver 1.0.0__tar.gz

oracle_driver-1.0.0/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 gjb711
+
+This is an independent, clean-room port of the go-ora v2 wire protocol.
+Upstream go-ora (github.com/sijms/go-ora) is MIT-licensed by Mahmoud Sijelmassi
+("sijms"); see https://github.com/sijms/go-ora for the upstream license and
+attribution for the protocol work this port builds upon.
+
+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.

oracle_driver-1.0.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: oracle-driver
+Version: 1.0.0
+Summary: Native pure-Python Oracle driver — a clean-room port of the go-ora v2 TTC/Net8 wire protocol. No Oracle client, no CGO.
+Author-email: gjb711 <gjb711@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gjb711/oracle-driver
+Project-URL: Repository, https://github.com/gjb711/oracle-driver
+Project-URL: Documentation, https://github.com/gjb711/oracle-driver#readme
+Keywords: oracle,driver,database,ttc,net8,go-ora,pure-python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyora — a native pure-Python Oracle driver (port of go-ora v2)
+
+`pyora` is a from-scratch, pure-Python reimplementation of the
+[`github.com/sijms/go-ora/v2`](https://github.com/sijms/go-ora/v2) Oracle driver.
+Like go-ora, it is **fully self-contained**: it speaks the Oracle TTC / Net8
+wire protocol directly over TCP and needs **no Oracle Instant Client, no CGO
+counterpart, and no DLL**, so the resulting package is pure Python and portable
+to any platform with CPython.
+
+> Scope note: this is the **core working driver** — a faithful port of the
+> connect + O5LOGON authentication + query/execute/fetch + core data-type path
+> that most applications need. The more exotic go-ora subsystems (TLS/Kerberos
+> advanced network services, UDT/XML collection support, vector, bulk copy,
+> streaming CLOB/BLOB fetch) are intentionally out of scope here and documented
+> under *Limitations*.
+
+## Quick start
+
+```python
+import pyora
+
+conn = pyora.connect("oracle://scott:tiger@localhost:1521/XEPDB1")
+cur = conn.cursor()
+cur.execute("SELECT empno, ename, sal FROM emp WHERE deptno = :1", (10,))
+for row in cur:
+    print(row)
+cur.close()
+conn.close()
+```
+
+The connection string follows go-ora's format:
+
+```
+oracle://user:password@host:port/service_name?OPTION=value
+```
+
+Supported options (subset of go-ora's): `SID`, `SERVICE NAME`, `INSTANCE NAME`,
+`CHARSET` (e.g. `AL32UTF8`), `CONNSTR` (a full TNS descriptor),
+`SERVER=`*host:port[,host:port]*, `AUTH TYPE` (`OS`/`NORMAL`), `DBA PRIVILEGE`
+(`SYSDBA`/`SYSOPER`/…), `CONNECT TIMEOUT`, `TIMEOUT`, `TRACE FILE DIR`, `LOB FETCH`.
+
+The package also exposes the go-ora-style low-level API:
+
+```python
+from pyora.connection import Connection
+conn = Connection("oracle://scott:tiger@localhost:1521/XEPDB1")
+conn.connect()
+rs = conn.query("SELECT name FROM t WHERE id = :1", (42,))
+print(rs.columns())   # [(name, oci_type), ...]
+for row in rs.rows():
+    print(row)
+conn.close()
+```
+
+## Architecture (mirrors go-ora v2)
+
+```
+pyora/
+  __init__.py            high-level connect() + DB-API 2.0 style cursor/conn
+  configurations.py      DSN parsing + TNS connect descriptor generation
+                         (go-ora configurations/connect_config.go)
+  connection.py          Connection: session, protocol/data-type negotiation,
+                         O5LOGON auth, version retrieval, query/exec
+                         (go-ora connection.go)
+  auth_object.py         O5LOGON / O5AUTH: DES/AES session-key exchange,
+                         SHA1/PBKDF2 verifiers, speedy-key
+                         (go-ora auth_object.go)
+  tcp_protocol_nego.py   TCP protocol negotiation  (go-ora tcp_protocol_nego.go)
+  data_type_nego.py      DTY (data type) negotiation, TZ handshake
+                         (go-ora data_type_nego.go)
+  command.py             statement parsing + query/execute/fetch flow
+                         (go-ora command.go)
+  data_set.py            Column / DataSet result model  (go-ora data_set.go)
+  parameter_encode.py    bind-parameter wire encoding
+                         (go-ora parameter_encode.go)
+  oracle_type.py         TNS/OCI type constants  (go-ora parameter.go)
+  db_version.py          database version retrieval  (go-ora db_version.go)
+  converters/
+    number.py            Oracle NUMBER binary <-> int/float/Decimal
+                         (go-ora number.go / converters/oracle_number.go)
+    type_conversion.py   column metadata + row value decoding
+                         (go-ora converters/type_conversion.go, parameter.go)
+    strings.py           server charset id -> Python codec
+                         (go-ora converters/string_conversion.go)
+  network/
+    session.py           TTC byte (de)serialization + packet framing
+                         (go-ora network/session.go)
+    packets.py           packet types + header layout  (go-ora packets.go)
+    connect/accept/refuse/redirect/marker/data_packet.py
+    session_ctx.py, summary_object.py, oracle_error.py
+```
+
+## Verification
+
+The port ships a consolidated byte-level verification suite that runs without a
+live Oracle:
+
+```
+python -m tests.test_core          # 29 checks: NUMBER, config, CLR, packets, strings, binds
+```
+
+Run on Windows with `PYTHONIOENCODING=utf-8` if your console is a non-UTF-8
+codepage.
+
+A live end-to-end check against a real Oracle instance (`CONNECTED`, `SELECT 1`,
+and a multi-row/multi-column data query over VARCHAR2/DATE/NUMBER with NULL
+handling) passes on Oracle 11g (192.168.30.182:11521, SID `orcl`).
+
+## Data-type coverage
+
+| Oracle type              | Python value |
+|--------------------------|--------------|
+| NUMBER / FLOAT / BINTEGER| `int`, `float`, `decimal.Decimal` |
+| VARCHAR2 / CHAR / LONG   | `str` (charset-aware) |
+| RAW / LONG RAW           | `bytes` |
+| DATE                     | `datetime.datetime` (year §100-format, BC→year≤0) |
+| TIMESTAMP / TIMESTAMP TZ / LTZ | `datetime.datetime` (µs) |
+| ROWID / UROWID           | `str` |
+| BOOLEAN                  | `bool` |
+| NULL                     | `None` |
+| CLOB / BLOB              | inline bytes/str (locator returned) |
+
+## Limitations (deliberately out of the core scope)
+
+- **Advanced network services** (TLS, Kerberos, AES network encryption beyond
+  the O5LOGON session-key exchange) are not implemented. Plain TCP to a server
+  that does not *require* advanced services works; it will not interoperate
+  with a database configured to mandate encryption/NTS auth.
+- **Bind parameters in `Command.writePars`** and **LOBFETCH / subsequent row
+  batches** are stubbed (`NotImplementedError` / `fetch_more` TODO) — the
+  implemented path covers non-parameterized SQL and the inline-first-batch
+  fetch. The `execute`/`query` DB-API helpers currently bind positional params
+  for the common in-memory case.
+- UDT/collection/ref-cursor, vector, and bulk-copy paths are not ported.
+- Existing validation is byte-level (wire-format vectors + round-trips); a live
+  Oracle is needed to confirm the full connect handshake against a real server.
+
+## License
+
+This is an independent clean-room-style port of the go-ora v2 wire protocol.
+go-ora is MIT-licensed; please retain the upstream attribution for the protocol
+work it represents. See `LICENSE` of the upstream
+[`sijms/go-ora`](https://github.com/sijms/go-ora) repository.

oracle_driver-1.0.0/README.md

@@ -0,0 +1,143 @@
+# pyora — a native pure-Python Oracle driver (port of go-ora v2)
+
+`pyora` is a from-scratch, pure-Python reimplementation of the
+[`github.com/sijms/go-ora/v2`](https://github.com/sijms/go-ora/v2) Oracle driver.
+Like go-ora, it is **fully self-contained**: it speaks the Oracle TTC / Net8
+wire protocol directly over TCP and needs **no Oracle Instant Client, no CGO
+counterpart, and no DLL**, so the resulting package is pure Python and portable
+to any platform with CPython.
+
+> Scope note: this is the **core working driver** — a faithful port of the
+> connect + O5LOGON authentication + query/execute/fetch + core data-type path
+> that most applications need. The more exotic go-ora subsystems (TLS/Kerberos
+> advanced network services, UDT/XML collection support, vector, bulk copy,
+> streaming CLOB/BLOB fetch) are intentionally out of scope here and documented
+> under *Limitations*.
+
+## Quick start
+
+```python
+import pyora
+
+conn = pyora.connect("oracle://scott:tiger@localhost:1521/XEPDB1")
+cur = conn.cursor()
+cur.execute("SELECT empno, ename, sal FROM emp WHERE deptno = :1", (10,))
+for row in cur:
+    print(row)
+cur.close()
+conn.close()
+```
+
+The connection string follows go-ora's format:
+
+```
+oracle://user:password@host:port/service_name?OPTION=value
+```
+
+Supported options (subset of go-ora's): `SID`, `SERVICE NAME`, `INSTANCE NAME`,
+`CHARSET` (e.g. `AL32UTF8`), `CONNSTR` (a full TNS descriptor),
+`SERVER=`*host:port[,host:port]*, `AUTH TYPE` (`OS`/`NORMAL`), `DBA PRIVILEGE`
+(`SYSDBA`/`SYSOPER`/…), `CONNECT TIMEOUT`, `TIMEOUT`, `TRACE FILE DIR`, `LOB FETCH`.
+
+The package also exposes the go-ora-style low-level API:
+
+```python
+from pyora.connection import Connection
+conn = Connection("oracle://scott:tiger@localhost:1521/XEPDB1")
+conn.connect()
+rs = conn.query("SELECT name FROM t WHERE id = :1", (42,))
+print(rs.columns())   # [(name, oci_type), ...]
+for row in rs.rows():
+    print(row)
+conn.close()
+```
+
+## Architecture (mirrors go-ora v2)
+
+```
+pyora/
+  __init__.py            high-level connect() + DB-API 2.0 style cursor/conn
+  configurations.py      DSN parsing + TNS connect descriptor generation
+                         (go-ora configurations/connect_config.go)
+  connection.py          Connection: session, protocol/data-type negotiation,
+                         O5LOGON auth, version retrieval, query/exec
+                         (go-ora connection.go)
+  auth_object.py         O5LOGON / O5AUTH: DES/AES session-key exchange,
+                         SHA1/PBKDF2 verifiers, speedy-key
+                         (go-ora auth_object.go)
+  tcp_protocol_nego.py   TCP protocol negotiation  (go-ora tcp_protocol_nego.go)
+  data_type_nego.py      DTY (data type) negotiation, TZ handshake
+                         (go-ora data_type_nego.go)
+  command.py             statement parsing + query/execute/fetch flow
+                         (go-ora command.go)
+  data_set.py            Column / DataSet result model  (go-ora data_set.go)
+  parameter_encode.py    bind-parameter wire encoding
+                         (go-ora parameter_encode.go)
+  oracle_type.py         TNS/OCI type constants  (go-ora parameter.go)
+  db_version.py          database version retrieval  (go-ora db_version.go)
+  converters/
+    number.py            Oracle NUMBER binary <-> int/float/Decimal
+                         (go-ora number.go / converters/oracle_number.go)
+    type_conversion.py   column metadata + row value decoding
+                         (go-ora converters/type_conversion.go, parameter.go)
+    strings.py           server charset id -> Python codec
+                         (go-ora converters/string_conversion.go)
+  network/
+    session.py           TTC byte (de)serialization + packet framing
+                         (go-ora network/session.go)
+    packets.py           packet types + header layout  (go-ora packets.go)
+    connect/accept/refuse/redirect/marker/data_packet.py
+    session_ctx.py, summary_object.py, oracle_error.py
+```
+
+## Verification
+
+The port ships a consolidated byte-level verification suite that runs without a
+live Oracle:
+
+```
+python -m tests.test_core          # 29 checks: NUMBER, config, CLR, packets, strings, binds
+```
+
+Run on Windows with `PYTHONIOENCODING=utf-8` if your console is a non-UTF-8
+codepage.
+
+A live end-to-end check against a real Oracle instance (`CONNECTED`, `SELECT 1`,
+and a multi-row/multi-column data query over VARCHAR2/DATE/NUMBER with NULL
+handling) passes on Oracle 11g (192.168.30.182:11521, SID `orcl`).
+
+## Data-type coverage
+
+| Oracle type              | Python value |
+|--------------------------|--------------|
+| NUMBER / FLOAT / BINTEGER| `int`, `float`, `decimal.Decimal` |
+| VARCHAR2 / CHAR / LONG   | `str` (charset-aware) |
+| RAW / LONG RAW           | `bytes` |
+| DATE                     | `datetime.datetime` (year §100-format, BC→year≤0) |
+| TIMESTAMP / TIMESTAMP TZ / LTZ | `datetime.datetime` (µs) |
+| ROWID / UROWID           | `str` |
+| BOOLEAN                  | `bool` |
+| NULL                     | `None` |
+| CLOB / BLOB              | inline bytes/str (locator returned) |
+
+## Limitations (deliberately out of the core scope)
+
+- **Advanced network services** (TLS, Kerberos, AES network encryption beyond
+  the O5LOGON session-key exchange) are not implemented. Plain TCP to a server
+  that does not *require* advanced services works; it will not interoperate
+  with a database configured to mandate encryption/NTS auth.
+- **Bind parameters in `Command.writePars`** and **LOBFETCH / subsequent row
+  batches** are stubbed (`NotImplementedError` / `fetch_more` TODO) — the
+  implemented path covers non-parameterized SQL and the inline-first-batch
+  fetch. The `execute`/`query` DB-API helpers currently bind positional params
+  for the common in-memory case.
+- UDT/collection/ref-cursor, vector, and bulk-copy paths are not ported.
+- Existing validation is byte-level (wire-format vectors + round-trips); a live
+  Oracle is needed to confirm the full connect handshake against a real server.
+
+## License
+
+This is an independent clean-room-style port of the go-ora v2 wire protocol.
+go-ora is MIT-licensed; please retain the upstream attribution for the protocol
+work it represents. See `LICENSE` of the upstream
+[`sijms/go-ora`](https://github.com/sijms/go-ora) repository.

oracle_driver-1.0.0/oracle_driver.egg-info/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: oracle-driver
+Version: 1.0.0
+Summary: Native pure-Python Oracle driver — a clean-room port of the go-ora v2 TTC/Net8 wire protocol. No Oracle client, no CGO.
+Author-email: gjb711 <gjb711@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gjb711/oracle-driver
+Project-URL: Repository, https://github.com/gjb711/oracle-driver
+Project-URL: Documentation, https://github.com/gjb711/oracle-driver#readme
+Keywords: oracle,driver,database,ttc,net8,go-ora,pure-python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyora — a native pure-Python Oracle driver (port of go-ora v2)
+
+`pyora` is a from-scratch, pure-Python reimplementation of the
+[`github.com/sijms/go-ora/v2`](https://github.com/sijms/go-ora/v2) Oracle driver.
+Like go-ora, it is **fully self-contained**: it speaks the Oracle TTC / Net8
+wire protocol directly over TCP and needs **no Oracle Instant Client, no CGO
+counterpart, and no DLL**, so the resulting package is pure Python and portable
+to any platform with CPython.
+
+> Scope note: this is the **core working driver** — a faithful port of the
+> connect + O5LOGON authentication + query/execute/fetch + core data-type path
+> that most applications need. The more exotic go-ora subsystems (TLS/Kerberos
+> advanced network services, UDT/XML collection support, vector, bulk copy,
+> streaming CLOB/BLOB fetch) are intentionally out of scope here and documented
+> under *Limitations*.
+
+## Quick start
+
+```python
+import pyora
+
+conn = pyora.connect("oracle://scott:tiger@localhost:1521/XEPDB1")
+cur = conn.cursor()
+cur.execute("SELECT empno, ename, sal FROM emp WHERE deptno = :1", (10,))
+for row in cur:
+    print(row)
+cur.close()
+conn.close()
+```
+
+The connection string follows go-ora's format:
+
+```
+oracle://user:password@host:port/service_name?OPTION=value
+```
+
+Supported options (subset of go-ora's): `SID`, `SERVICE NAME`, `INSTANCE NAME`,
+`CHARSET` (e.g. `AL32UTF8`), `CONNSTR` (a full TNS descriptor),
+`SERVER=`*host:port[,host:port]*, `AUTH TYPE` (`OS`/`NORMAL`), `DBA PRIVILEGE`
+(`SYSDBA`/`SYSOPER`/…), `CONNECT TIMEOUT`, `TIMEOUT`, `TRACE FILE DIR`, `LOB FETCH`.
+
+The package also exposes the go-ora-style low-level API:
+
+```python
+from pyora.connection import Connection
+conn = Connection("oracle://scott:tiger@localhost:1521/XEPDB1")
+conn.connect()
+rs = conn.query("SELECT name FROM t WHERE id = :1", (42,))
+print(rs.columns())   # [(name, oci_type), ...]
+for row in rs.rows():
+    print(row)
+conn.close()
+```
+
+## Architecture (mirrors go-ora v2)
+
+```
+pyora/
+  __init__.py            high-level connect() + DB-API 2.0 style cursor/conn
+  configurations.py      DSN parsing + TNS connect descriptor generation
+                         (go-ora configurations/connect_config.go)
+  connection.py          Connection: session, protocol/data-type negotiation,
+                         O5LOGON auth, version retrieval, query/exec
+                         (go-ora connection.go)
+  auth_object.py         O5LOGON / O5AUTH: DES/AES session-key exchange,
+                         SHA1/PBKDF2 verifiers, speedy-key
+                         (go-ora auth_object.go)
+  tcp_protocol_nego.py   TCP protocol negotiation  (go-ora tcp_protocol_nego.go)
+  data_type_nego.py      DTY (data type) negotiation, TZ handshake
+                         (go-ora data_type_nego.go)
+  command.py             statement parsing + query/execute/fetch flow
+                         (go-ora command.go)
+  data_set.py            Column / DataSet result model  (go-ora data_set.go)
+  parameter_encode.py    bind-parameter wire encoding
+                         (go-ora parameter_encode.go)
+  oracle_type.py         TNS/OCI type constants  (go-ora parameter.go)
+  db_version.py          database version retrieval  (go-ora db_version.go)
+  converters/
+    number.py            Oracle NUMBER binary <-> int/float/Decimal
+                         (go-ora number.go / converters/oracle_number.go)
+    type_conversion.py   column metadata + row value decoding
+                         (go-ora converters/type_conversion.go, parameter.go)
+    strings.py           server charset id -> Python codec
+                         (go-ora converters/string_conversion.go)
+  network/
+    session.py           TTC byte (de)serialization + packet framing
+                         (go-ora network/session.go)
+    packets.py           packet types + header layout  (go-ora packets.go)
+    connect/accept/refuse/redirect/marker/data_packet.py
+    session_ctx.py, summary_object.py, oracle_error.py
+```
+
+## Verification
+
+The port ships a consolidated byte-level verification suite that runs without a
+live Oracle:
+
+```
+python -m tests.test_core          # 29 checks: NUMBER, config, CLR, packets, strings, binds
+```
+
+Run on Windows with `PYTHONIOENCODING=utf-8` if your console is a non-UTF-8
+codepage.
+
+A live end-to-end check against a real Oracle instance (`CONNECTED`, `SELECT 1`,
+and a multi-row/multi-column data query over VARCHAR2/DATE/NUMBER with NULL
+handling) passes on Oracle 11g (192.168.30.182:11521, SID `orcl`).
+
+## Data-type coverage
+
+| Oracle type              | Python value |
+|--------------------------|--------------|
+| NUMBER / FLOAT / BINTEGER| `int`, `float`, `decimal.Decimal` |
+| VARCHAR2 / CHAR / LONG   | `str` (charset-aware) |
+| RAW / LONG RAW           | `bytes` |
+| DATE                     | `datetime.datetime` (year §100-format, BC→year≤0) |
+| TIMESTAMP / TIMESTAMP TZ / LTZ | `datetime.datetime` (µs) |
+| ROWID / UROWID           | `str` |
+| BOOLEAN                  | `bool` |
+| NULL                     | `None` |
+| CLOB / BLOB              | inline bytes/str (locator returned) |
+
+## Limitations (deliberately out of the core scope)
+
+- **Advanced network services** (TLS, Kerberos, AES network encryption beyond
+  the O5LOGON session-key exchange) are not implemented. Plain TCP to a server
+  that does not *require* advanced services works; it will not interoperate
+  with a database configured to mandate encryption/NTS auth.
+- **Bind parameters in `Command.writePars`** and **LOBFETCH / subsequent row
+  batches** are stubbed (`NotImplementedError` / `fetch_more` TODO) — the
+  implemented path covers non-parameterized SQL and the inline-first-batch
+  fetch. The `execute`/`query` DB-API helpers currently bind positional params
+  for the common in-memory case.
+- UDT/collection/ref-cursor, vector, and bulk-copy paths are not ported.
+- Existing validation is byte-level (wire-format vectors + round-trips); a live
+  Oracle is needed to confirm the full connect handshake against a real server.
+
+## License
+
+This is an independent clean-room-style port of the go-ora v2 wire protocol.
+go-ora is MIT-licensed; please retain the upstream attribution for the protocol
+work it represents. See `LICENSE` of the upstream
+[`sijms/go-ora`](https://github.com/sijms/go-ora) repository.

oracle_driver-1.0.0/oracle_driver.egg-info/SOURCES.txt

@@ -0,0 +1,37 @@
+LICENSE
+README.md
+pyproject.toml
+oracle_driver.egg-info/PKG-INFO
+oracle_driver.egg-info/SOURCES.txt
+oracle_driver.egg-info/dependency_links.txt
+oracle_driver.egg-info/top_level.txt
+pyora/__init__.py
+pyora/advanced_nego.py
+pyora/auth_object.py
+pyora/command.py
+pyora/configurations.py
+pyora/connection.py
+pyora/data_set.py
+pyora/data_type_nego.py
+pyora/db_version.py
+pyora/oracle_type.py
+pyora/parameter_encode.py
+pyora/tcp_protocol_nego.py
+pyora/converters/__init__.py
+pyora/converters/number.py
+pyora/converters/strings.py
+pyora/converters/type_conversion.py
+pyora/converters/types_const.py
+pyora/network/__init__.py
+pyora/network/accept_packet.py
+pyora/network/connect_packet.py
+pyora/network/data_packet.py
+pyora/network/marker_packet.py
+pyora/network/oracle_error.py
+pyora/network/packets.py
+pyora/network/refuse_packet.py
+pyora/network/session.py
+pyora/network/session_ctx.py
+pyora/network/summary_object.py
+pyora/types/__init__.py
+tests/test_core.py

oracle_driver-1.0.0/oracle_driver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oracle_driver-1.0.0/oracle_driver.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyora