PyD2XX 0.0.1__tar.gz

pyd2xx-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Hector Soto
+
+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.

pyd2xx-0.0.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: PyD2XX
+Version: 0.0.1
+Summary: A Python wrapper for the FTDI D@XX library.
+Keywords: FTDI,ftdichip,PyD2XX,D2XX,FTD2XX
+Author-Email: Hector Soto <hector.soto@ftdichip.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Project-URL: GitHub_Repo, https://github.com/S-Hector/PyD3XX
+Project-URL: FTDI_Homepage, https://ftdichip.com/
+Project-URL: FTDI_D3XX_Drivers, https://ftdichip.com/drivers/d2xx-drivers/
+Project-URL: D2XX_Programming_Guide, https://ftdichip.com/wp-content/uploads/2025/06/D2XX_Programmers_Guide.pdf
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# PyD2XX
+A Python wrapper for the FTDI D2XX library.
+PyD2XX will eventually support Windows, Linux, and MacOS.  
+Most D2XX dynamic library variants are included in this package, so you don't need to include them directly in your project!  
+\^You don't need and should not have any D2XX .dll, .dylib, or .so file in your script's directory.  
+This was designed so the user needs zero ctypes knowledge and not need to import anything besides PyD2XX to interact with D2XX devices. The user should never have to interact with a ctypes object or method.  
+
+## Documentation
+None yet! This is still in extremely early development mainly as a test.
+While the MAJOR version is 0, this is considered incomplete and not a full translation of the D2XX library to Python.
+The API and behavior can change at any time until the MAJOR version is 1.
+You should use PyFTDI instead: https://github.com/eblot/pyftdi
+
+## Licensing
+The PyD2XX package is licensed under MIT.
+The underlying D2XX libraries distributed with this package fall under FTDI's license.
+FTDI's License: https://ftdichip.com/driver-licence-terms-details/

pyd2xx-0.0.1/README.md

@@ -0,0 +1,17 @@
+# PyD2XX
+A Python wrapper for the FTDI D2XX library.
+PyD2XX will eventually support Windows, Linux, and MacOS.  
+Most D2XX dynamic library variants are included in this package, so you don't need to include them directly in your project!  
+\^You don't need and should not have any D2XX .dll, .dylib, or .so file in your script's directory.  
+This was designed so the user needs zero ctypes knowledge and not need to import anything besides PyD2XX to interact with D2XX devices. The user should never have to interact with a ctypes object or method.  
+
+## Documentation
+None yet! This is still in extremely early development mainly as a test.
+While the MAJOR version is 0, this is considered incomplete and not a full translation of the D2XX library to Python.
+The API and behavior can change at any time until the MAJOR version is 1.
+You should use PyFTDI instead: https://github.com/eblot/pyftdi
+
+## Licensing
+The PyD2XX package is licensed under MIT.
+The underlying D2XX libraries distributed with this package fall under FTDI's license.
+FTDI's License: https://ftdichip.com/driver-licence-terms-details/

pyd2xx-0.0.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm.build]
+includes = [
+    "src/PyD2XX/",
+]
+
+[project]
+name = "PyD2XX"
+version = "0.0.1"
+authors = [
+    { name = "Hector Soto", email = "hector.soto@ftdichip.com" },
+]
+description = "A Python wrapper for the FTDI D@XX library."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "FTDI",
+    "ftdichip",
+    "PyD2XX",
+    "D2XX",
+    "FTD2XX",
+]
+
+[project.urls]
+GitHub_Repo = "https://github.com/S-Hector/PyD3XX"
+FTDI_Homepage = "https://ftdichip.com/"
+FTDI_D3XX_Drivers = "https://ftdichip.com/drivers/d2xx-drivers/"
+D2XX_Programming_Guide = "https://ftdichip.com/wp-content/uploads/2025/06/D2XX_Programmers_Guide.pdf"

pyd2xx-0.0.1/src/PyD2XX/Licenses/FTDI DRIVER LICENSE.txt

@@ -0,0 +1,150 @@
+The D2XX library files fall under FTDI's license: https://ftdichip.com/driver-licence-terms-details/
+FTDI LICENSE:
+[
+Driver Licence Terms – Details
+IMPORTANT NOTICE: PLEASE READ CAREFULLY BEFORE INSTALLING THE RELEVANT SOFTWARE: This licence agreement (“Licence”) is a legal agreement between you (“Licencee” or “you”) and Future Technology Devices International Limited of 2 Seaward Place, Centurion Business Park, Glasgow, Scotland, G41 1HH (UK Company Number SC136640) (“Licensor” or “we) for use of driver software provided by the Licensor (“Software”).
+
+BY INSTALLING OR USING THIS SOFTWARE YOU AGREE TO THE TERMS OF THIS LICENCE WHICH WILL BIND YOU.  IF YOU DO NOT AGREE TO THE TERMS OF THIS LICENCE, WE ARE UNWILLING TO LICENSE THE SOFTWARE TO YOU AND YOU MUST DISCONTINUE INSTALLATION OF THE SOFTWARE NOW.
+
+1.	Grant and scope of licence
+
+1.1	In consideration of you agreeing to abide by the terms of this Licence, the Licensor hereby grants to you a non-exclusive, non-transferable, royalty free licence to use the Software on the terms of this Licence.
+
+1.2	In this Licence a “Genuine FTDI Component” means an item of hardware that was manufactured for, and sold by, the Licensor or a member of the Licensor’s group of companies. It does not include any counterfeit or fake products.
+
+1.3	If you are a manufacturer of a device that includes a Genuine FTDI Component (each a “Device“) then you may install the Software onto that device. If you are a seller or distributor of a Device then You may distribute the Software with the Device. If you are a user of a Device then you may install the Software on the Device, or onto a computer system in order to use the Device.
+
+1.4	In each of those cases you may:
+
+1.4.1	Install and use the Software for your purposes only; and
+
+1.4.2	Only use the Software in conjunction with products based on and/or incorporating a Genuine FTDI Component.
+
+1.5	The Software will not function properly on or with a component that is not a Genuine FTDI Component. Use of the Software as a driver for, or installation of the Software onto,  a component that is not a Genuine FTDI Component, including without limitation counterfeit components, MAY IRRETRIEVABLY DAMAGE THAT COMPONENT.  It is the Licensee’s responsibility to make sure that all chips it installs the Software on, or uses the Software as a driver for, are Genuine FTDI Components. If in doubt then contact the Licensor.
+
+2.	If a custom vendor ID and/or product ID or description string are used, it is the responsibility of the product manufacturer to maintain any changes and subsequent WHQL re-certification as a result of making these changes.
+
+3.	Licensee’s undertakings
+
+3.1	Except as expressly set out in this Licence or as permitted by any local law, you undertake:
+
+3.1.1	not to copy the Software, except where such copying is incidental to normal use of the Software or where it is necessary for the purpose of back-up or operational security;
+
+3.1.2	not to rent, lease, sub-license, loan, translate, merge, adapt, vary or modify the Software or any part of it;
+
+3.1.3	not to make alterations to, or modifications of, the whole or any part of the Software nor permit the Software or any part of it to be combined with, or become incorporated in, any other programs;
+
+3.1.4	not to disassemble, de-compile, reverse engineer or create derivative works based on the whole or any part of the Software;
+
+3.1.5	to keep all copies of the Software secure;
+
+3.1.6	to include the copyright notice of the Licensor on all entire and partial copies of the Software in any form; and
+
+3.1.7	not to provide, or otherwise make available, the Software in any form, in whole or in part (including, but not limited to, program listings, object and source program listings, object code and source code) to any person.
+
+4.	Intellectual property rights
+
+4.1	You acknowledge that all intellectual property rights in the Software throughout the world belong to the Licensor, that rights in the Software are licensed (not sold) to you, and that you have no rights in, or to, the Software other than the right to use them in accordance with the terms of this Licence.
+
+5.	Warranty
+
+5.1	To the maximum extent permitted by applicable law, the software is provided “as is”.
+
+5.2	All implied warranties, implied conditions and/or implied licences are excluded from this Licence, including but not limited to implied warranties of quality and/or fitness for purpose (in all cases) to the fullest extent permitted by law.
+
+5.3	You acknowledge that the Software has not been developed to meet your individual requirements and that the Software may not be uninterrupted or free of bugs or errors.
+
+6.	Licensor’s liability
+
+6.1	To the maximum extent permitted by applicable law, in no event shall the Licensor be liable for any:
+
+6.1.1	special loss or damage;
+
+6.1.2	incidental loss or damage;
+
+6.1.3	indirect or consequential loss or damage:
+
+6.1.4	loss of income;
+
+6.1.5	loss of business;
+
+6.1.6	loss of profits;
+
+6.1.7	loss of revenue;
+
+6.1.8	loss of  contracts;
+
+6.1.9	business interruption;
+
+6.1.10	loss of the use of money or anticipated savings;
+
+6.1.11	loss of information;
+
+6.1.12	loss of opportunity;
+
+6.1.13	loss of  goodwill or reputation; and/or
+
+6.1.14	loss of, damage to or corruption of data;
+
+(in each case) of any kind howsoever arising and whether caused by delict (including negligence), breach of contract or otherwise.
+
+6.2	FTDI’s total liability to you in relation to the Software shall not exceed 500 US Dollars.
+
+6.3	Nothing in this Licence limits or excludes liability for death or personal injury or for fraud.
+
+7.	Termination
+
+7.1	The Licensor may terminate this Licence immediately if:
+
+7.1.1	you fail to comply with any of the terms and conditions of the Licence; or
+
+7.1.2	you commence or participate in any legal proceedings against the Licensor.
+
+7.2	Upon termination:
+
+7.2.1	all rights granted to you under this Licence shall cease;
+
+7.2.2	you must cease all activities authorised by this Licence; and
+
+7.2.3	you must immediately delete or remove the Software from all computer equipment in your possession and immediately destroy all copies of the Software then in your possession, custody or control.
+
+8.	Transfer of rights and obligations
+
+8.1	You may not transfer, assign, charge or otherwise dispose of this Licence, or any of your rights or obligations arising under it.
+
+8.2	The Licensor may transfer, assign, charge, sub-contract or otherwise dispose of this Licence, or any of his rights or obligations arising under it, at any time during the term of the Licence.
+
+9.	Waiver
+
+9.1	If the Licensor fails, at any time during the term of this Licence, to insist on strict performance of any of your obligations under this Licence, or if the Licensor fails to exercise any of the rights or remedies to which he is entitled under this Licence, this shall not constitute a waiver of such rights or remedies and shall not relieve you from compliance with such obligations.
+
+9.2	A waiver by the Licensor of any default shall not constitute a waiver of any subsequent default.
+
+9.3	No waiver by the Licensor of any of these terms and conditions shall be effective unless it is expressly stated to be a waiver and is communicated to you in writing.
+
+10.	Severability
+
+	If any of the terms of this Licence are determined by any competent authority to be invalid, unlawful or unenforceable to any extent, such term, condition or provision will to that extent be severed from the remaining terms, conditions and provisions which will continue to be valid to the fullest extent permitted by law.
+
+11.	Entire agreement
+
+11.1	This Licence constitutes the whole agreement between us and supersedes any previous arrangement, understanding or agreement between us, relating to the licensing of the Software.
+
+11.2	Each party acknowledges that in entering into this Licence it does not rely on any statement, representation, warranty or understanding other than those expressly set out in this Licence.  Each party agrees that it will have no remedy in respect of any statement, representation, warranty or understanding that is not expressly set out in this Licence. Each party agrees that its only remedy in respect of those representations, statements, assurances and warranties that are set out in this Licence will be for breach of contract in accordance with the terms of this Licence.
+
+11.3	The parties agree that nothing in this Licence will limit or exclude any liability they may have for fraud.
+
+12.	Miscellaneous
+
+12.1	This Licence does not create a partnership or joint venture between the parties to it, nor authorise a party to act as agent for the other.
+
+12.2	This Licence does not create any legal rights enforceable by any third party.
+
+12.3	This Licence may only be varied by express written legal agreement between the parties.
+
+13.	Law and jurisdiction
+
+	This Licence, its subject matter or its formation (including non-contractual disputes or claims) shall be governed by and construed in accordance with Scots law and submitted to the non-exclusive jurisdiction of the Scottish courts.
+
+Copyright © 2026 Future Technology Devices International Limited. All Rights Reserved
+]

pyd2xx-0.0.1/src/PyD2XX/Licenses/PyD2XX LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 S-Hector
+
+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.

pyd2xx-0.0.1/src/PyD2XX/PyD2XX.py

@@ -0,0 +1,404 @@
+# Created by Hector Soto
+# A Python conversion of the FTD2XX library.
+# While the MAJOR version is 0, this is considered incomplete
+# and not a full translation of the D2XX library to Python.
+# The API and behavior can change at any time until the MAJOR version is 1.
+
+print("PyD2XX: PyD2XX is still in EXTREMELY early development!")
+print("PyD2XX: You should use PyFTDI instead: https://github.com/eblot/pyftdi")
+
+import ctypes
+import ctypes.wintypes
+import typing
+import platform as _Platform
+import subprocess
+import locale
+
+from importlib.resources import files as _files
+from sys import platform as Platform
+
+# ---| Python Library Specific Definitions |---
+
+VERSION = "0.0.1"
+VERSION_TEST = "0.0.1_schimbarea_direcției"
+
+PRINT_NONE =            int("00000", 2) # Print no messages.
+PRINT_ERROR_CRITICAL =  int("00001", 2) # Print critical error messages.
+PRINT_ERROR_MAJOR =     int("00010", 2) # Print major error messages.
+PRINT_ERROR_MINOR =     int("00100", 2) # Print minor error messages.
+PRINT_ERROR_ALL =       int("00111", 2) # Print all error messages.
+
+PRINT_INFO_START =      int("01000", 2) # Print informational startup messages.
+PRINT_INFO_DEVICE =     int("10000", 2) # Print device information.
+PRINT_INFO_ALL =        int("11000", 2) # Print all informational messages.
+PRINT_ALL =             int("11111", 2) # Print all messages.
+
+_PrintLevel = PRINT_NONE # What levels of printing are allowed.
+_PrintQueue = []
+
+def SetPrintLevel(PrintLevel: int) -> int:
+    global _PrintLevel
+    global _PrintQueue
+    _PrintLevel = PrintLevel
+    if _PrintQueue:
+        for Message in _PrintQueue:
+            _Print(Message[0], Message[1], False)
+        _PrintQueue = []
+    return FT_OK
+
+def _Print(Message: str, Level: int, Queue: bool):
+    if Queue:
+        _PrintQueue.append([Message, Level])
+    elif(Level & PRINT_ERROR_CRITICAL & _PrintLevel):
+        print("PyD2XX - CRITICAL ERROR: " + Message)
+    elif(Level & PRINT_ERROR_MAJOR & _PrintLevel):
+        print("PyD2XX - MAJOR ERROR: " + Message)
+    elif(Level & PRINT_ERROR_MINOR & _PrintLevel):
+        print("PyD2XX - MINOR ERROR: " + Message)
+    elif(Level & PRINT_INFO_START & _PrintLevel):
+        print("PyD2XX - Startup INFO: " + Message)
+
+# Determine OS and type sizes.
+if (Platform.startswith("linux")):
+    Platform = "linux"
+elif (Platform.startswith("win")):
+    Platform = "windows"
+elif (Platform.startswith("darwin")):
+    Platform = "darwin"
+elif (Platform.startswith("cygwin")):
+    Platform = "windows"
+else: # Default to linux if we didn't catch the platform.
+    _Print("OS UNKNOWN: Assuming OS is linux.", PRINT_INFO_START, True)
+    Platform = "linux"
+
+if Platform == "linux":
+    import gc
+
+_IsARM = _Platform.machine().startswith('arm') or _Platform.machine().startswith('aarch64')
+
+if ((Platform == "linux") or (Platform == "darwin")): #Fix type sizes for Linux and macOS
+    ctypes.c_ulong = ctypes.c_int32
+    ctypes.wintypes.DWORD = ctypes.c_int32
+
+SIZE_UINT = ctypes.sizeof(ctypes.c_uint)
+SIZE_ULONG = ctypes.sizeof(ctypes.c_ulong)
+SIZE_SHORT = ctypes.sizeof(ctypes.c_short)
+SIZE_CHAR = ctypes.sizeof(ctypes.c_char)
+SIZE_WCHAR = ctypes.sizeof(ctypes.c_wchar)
+SIZE_PTR = ctypes.sizeof(ctypes.c_void_p)
+SIZE_DWORD = ctypes.sizeof(ctypes.wintypes.DWORD)
+
+# ---| FTD2XX C/C++ HEADER EQUIVALENT STARTS HERE |---
+# THIS IS NOT A FULL EQUIVALENT TO THE FTD2XX HEADER.
+# I HAVE TAKEN MY OWN LIBERTIES ON HOW TO REPRESENT STRUCTS.
+
+NULL = ctypes.c_void_p(0)
+
+#FT_STATUS values.
+FT_OK = 0
+FT_INVALID_HANDLE = 1
+FT_DEVICE_NOT_FOUND = 2
+FT_DEVICE_NOT_OPENED = 3
+FT_IO_ERROR = 4
+FT_INSUFFICIENT_RESOURCES = 5
+FT_INVALID_PARAMETER = 6
+FT_INVALID_BAUD_RATE = 7
+FT_DEVICE_NOT_OPENED_FOR_ERASE = 8
+FT_DEVICE_NOT_OPENED_FOR_WRITE = 9
+FT_FAILED_TO_WRITE_DEVICE = 10
+FT_EEPROM_READ_FAILED = 11
+FT_EEPROM_WRITE_FAILED = 12
+FT_EEPROM_ERASE_FAILED = 13
+FT_EEPROM_NOT_PRESENT = 14
+FT_EEPROM_NOT_PROGRAMMED = 15
+FT_INVALID_ARGS = 16
+FT_NOT_SUPPORTED = 17
+FT_OTHER_ERROR = 18
+FT_DEVICE_LIST_NOT_READY = 19
+
+# Describe dictionaries for easier error code conversion.
+FT_STATUS_STR = {
+    FT_OK: "FT_OK",
+    FT_INVALID_HANDLE: "FT_INVALID_HANDLE",
+    FT_DEVICE_NOT_FOUND: "FT_DEVICE_NOT_FOUND",
+    FT_DEVICE_NOT_OPENED: "FT_DEVICE_NOT_OPENED",
+    FT_IO_ERROR: "FT_IO_ERROR",
+    FT_INSUFFICIENT_RESOURCES: "FT_INSUFFICIENT_RESOURCES",
+    FT_INVALID_PARAMETER: "FT_INVALID_PARAMETER",
+    FT_INVALID_BAUD_RATE: "FT_INVALID_BAUD_RATE",
+    FT_DEVICE_NOT_OPENED_FOR_ERASE: "FT_DEVICE_NOT_OPENED_FOR_ERASE",
+    FT_DEVICE_NOT_OPENED_FOR_WRITE: "FT_DEVICE_NOT_OPENED_FOR_WRITE",
+    FT_FAILED_TO_WRITE_DEVICE: "FT_FAILED_TO_WRITE_DEVICE",
+    FT_EEPROM_READ_FAILED: "FT_EEPROM_READ_FAILED",
+    FT_EEPROM_WRITE_FAILED: "FT_EEPROM_WRITE_FAILED",
+    FT_EEPROM_ERASE_FAILED: "FT_EEPROM_ERASE_FAILED",
+    FT_EEPROM_NOT_PRESENT: "FT_EEPROM_NOT_PRESENT",
+    FT_EEPROM_NOT_PROGRAMMED: "FT_EEPROM_NOT_PROGRAMMED",
+    FT_INVALID_ARGS: "FT_INVALID_ARGS",
+    FT_NOT_SUPPORTED: "FT_NOT_SUPPORTED",
+    FT_OTHER_ERROR: "FT_OTHER_ERROR"
+}
+FT_STATUS = {v: k for k, v in FT_STATUS_STR.items()}
+
+FT_DEVICE_BM = 0
+FT_DEVICE_AM = 1
+FT_DEVICE_100AX = 2
+FT_DEVICE_UNKNOWN = 3
+FT_DEVICE_2232C = 4
+FT_DEVICE_232R = 5
+FT_DEVICE_2232H = 6
+FT_DEVICE_4232H = 7
+FT_DEVICE_232H = 8
+FT_DEVICE_X_SERIES = 9
+FT_DEVICE_4222H_0 = 10
+FT_DEVICE_4222H_1_2 = 11
+FT_DEVICE_4222H_3 = 12
+FT_DEVICE_4222_PROG = 13
+FT_DEVICE_900 = 14
+FT_DEVICE_930 = 15
+FT_DEVICE_UMFTPD3A = 16
+FT_DEVICE_2233HP = 17
+FT_DEVICE_4233HP = 18
+FT_DEVICE_2232HP = 19
+FT_DEVICE_4232HP = 20
+FT_DEVICE_233HP = 21
+FT_DEVICE_232HP = 22
+FT_DEVICE_2232HA = 23
+FT_DEVICE_4232HA = 24
+FT_DEVICE_232RN = 25
+FT_DEVICE_2233HPN = 26
+FT_DEVICE_4233HPN = 27
+FT_DEVICE_2232HPN = 28
+FT_DEVICE_4232HPN = 29
+FT_DEVICE_233HPN = 30
+FT_DEVICE_232HPN = 31
+FT_DEVICE_BM_A = 32
+
+FT_DEVICE_STR = {
+    FT_DEVICE_BM: "FT_DEVICE_BM",
+	FT_DEVICE_AM: "FT_DEVICE_AM",
+	FT_DEVICE_100AX: "FT_DEVICE_100AX",
+	FT_DEVICE_UNKNOWN: "FT_DEVICE_UNKNOWN",
+	FT_DEVICE_2232C: "FT_DEVICE_2232C",
+	FT_DEVICE_232R: "FT_DEVICE_232R",
+	FT_DEVICE_2232H: "FT_DEVICE_2232H",
+	FT_DEVICE_4232H: "FT_DEVICE_4232H",
+	FT_DEVICE_232H: "FT_DEVICE_232H",
+	FT_DEVICE_X_SERIES: "FT_DEVICE_X_SERIES",
+	FT_DEVICE_4222H_0: "FT_DEVICE_4222H_0",
+	FT_DEVICE_4222H_1_2: "FT_DEVICE_4222H_1_2",
+	FT_DEVICE_4222H_3: "FT_DEVICE_4222H_3",
+	FT_DEVICE_4222_PROG: "FT_DEVICE_4222_PROG",
+	FT_DEVICE_900: "FT_DEVICE_900",
+	FT_DEVICE_930: "FT_DEVICE_930",
+	FT_DEVICE_UMFTPD3A: "FT_DEVICE_UMFTPD3A",
+	FT_DEVICE_2233HP: "FT_DEVICE_2233HP",
+	FT_DEVICE_4233HP: "FT_DEVICE_4233HP",
+	FT_DEVICE_2232HP: "FT_DEVICE_2232HP",
+	FT_DEVICE_4232HP: "FT_DEVICE_4232HP",
+	FT_DEVICE_233HP: "FT_DEVICE_233HP",
+	FT_DEVICE_232HP: "FT_DEVICE_232HP",
+	FT_DEVICE_2232HA: "FT_DEVICE_2232HA",
+	FT_DEVICE_4232HA: "FT_DEVICE_4232HA",
+	FT_DEVICE_232RN: "FT_DEVICE_232RN",
+	FT_DEVICE_2233HPN: "FT_DEVICE_2233HPN",
+	FT_DEVICE_4233HPN: "FT_DEVICE_4233HPN",
+	FT_DEVICE_2232HPN: "FT_DEVICE_2232HPN",
+	FT_DEVICE_4232HPN: "FT_DEVICE_4232HPN",
+	FT_DEVICE_233HPN: "FT_DEVICE_233HPN",
+	FT_DEVICE_232HPN: "FT_DEVICE_232HPN",
+	FT_DEVICE_BM_A: "FT_DEVICE_BM_A"
+}
+FT_DEVICE = {v: k for k, v in FT_DEVICE_STR.items()}
+
+FT_BITMODE_RESET = int("0x00", 16)
+FT_BITMODE_ASYNC_BITBANG = int("0x01", 16)
+FT_BITMODE_MPSSE = int("0x02", 16)
+FT_BITMODE_SYNC_BITBANG = int("0x04", 16)
+FT_BITMODE_MCU_HOST = int("0x08", 16)
+FT_BITMODE_FAST_SERIAL = int("0x10", 16)
+FT_BITMODE_CBUS_BITBANG = int("0x20", 16)
+FT_BITMODE_SYNC_FIFO = int("0x40", 16)
+
+FT_FLAGS_OPENED = 1
+FT_FLAGS_HISPEED = 2
+
+class FT_Buffer:
+    def __init__(self, Size: int = None):
+        if(isinstance(Size, int)):
+            self._RawAddress = ctypes.c_buffer(init=0, size=Size)
+            self._Length = Size
+        else:
+            self._RawAddress = "FT_OTHER_ERROR"
+            self._Length = 0
+    def from_int(Integer: int):
+        NewBuffer = FT_Buffer()
+        if(isinstance(Integer, int)):
+            NewBuffer._RawAddress = ctypes.c_buffer(Integer.to_bytes(SIZE_UINT, "little"), SIZE_UINT)
+            NewBuffer._Length = SIZE_UINT
+        else:
+            _Print("FT_Buffer(int), not given an int!", PRINT_ERROR_MINOR, False)
+        return NewBuffer
+    def from_str(String: str):
+        NewBuffer = FT_Buffer()
+        if(isinstance(String, str)):
+            NewBuffer._Length = len(String) + 1
+            NewBuffer._RawAddress = ctypes.create_string_buffer(init=String.encode("ascii"))
+        else:
+            _Print("FT_Buffer(str), not given a str!", PRINT_ERROR_MINOR, False)
+        return NewBuffer
+    def from_bytearray(ByteArray: bytearray):
+        NewBuffer = FT_Buffer()
+        if(isinstance(ByteArray, bytearray)):
+            NewBuffer._Length = len(ByteArray)
+            NewBuffer._RawAddress = ctypes.c_buffer(init=bytes(ByteArray), size=NewBuffer._Length)
+        else:
+            _Print("FT_Buffer(bytearray), not given a bytearray!", PRINT_ERROR_MINOR, False)
+        return NewBuffer
+    def from_bytes(Bytes: bytes):
+        NewBuffer = FT_Buffer()
+        if(isinstance(Bytes, bytes)):
+            NewBuffer._Length = len(Bytes)
+            NewBuffer._RawAddress = ctypes.c_buffer(init=Bytes, size=NewBuffer._Length)
+        else:
+            _Print("FT_Buffer(bytes), not given bytes!", PRINT_ERROR_MINOR, False)
+        return NewBuffer
+    def Value(self) -> bytearray:
+        if isinstance(self._RawAddress, str):
+            return self._RawAddress.encode("ascii")
+        return bytearray(self._RawAddress)
+
+class _FT_DEVICE_LIST_INFO_NODE(ctypes.Structure):
+    _fields_ = [
+        ("Flags", ctypes.c_int32), #ULONG for Windows is 4 bytes. Linux library follows same byte alignment against normal convention.
+        ("Type", ctypes.c_int32),
+        ("ID", ctypes.c_int32),
+        ("LocID", ctypes.c_int32),
+        ("SerialNumber", ctypes.c_char * 16),
+        ("Description", ctypes.c_char * 64)
+    ]
+class FT_Device:
+    _Handle = "FT_OTHER_ERROR"
+    Handle = "FT_OTHER_ERROR"
+    Flags = 0
+    Type = 0
+    ID = 0
+    LocID = 0
+    SerialNumber = ""
+    Description = ""
+
+def _CreateDevice():
+    NewDevice = FT_Device()
+    NewDevice._Handle = ctypes.c_void_p(0)
+    NewDevice.Flags = 0
+    NewDevice.Type = 0
+    NewDevice.ID = 0
+    NewDevice.LocID = 0
+    NewDevice.SerialNumber = ""
+    NewDevice.Description = ""
+    return NewDevice
+
+# ---| END OF EQUIVALENT HEADER PORTION |---
+
+# ---| LIBRARY INCLUSION PART |---
+_Python64 = (ctypes.sizeof(ctypes.c_void_p) == 8) # True if 64-bit version of Python is running.
+
+# ---| Try to Load Dynamic Library |---
+_LibraryFile = ""
+_LibraryFile += "FTD2XX" if (Platform=="windows") else "libftd2xx"
+_LibraryFile += ("_ARM" if (_IsARM and (Platform!="darwin")) else "")
+_LibraryFile += ("_32" if not(_Python64) else "")
+_LibraryFile += ".dll" if (Platform=="windows") else (".dylib" if (Platform=="darwin") else ".so")
+_DLL_Path = str(_files("PyD2XX").joinpath(_LibraryFile))
+try:
+    if(Platform == "windows"):
+        _DLL = ctypes.windll.LoadLibrary(_DLL_Path) # Check if dll exists in same directory as executable.
+    else:
+        _DLL = ctypes.cdll.LoadLibrary(_DLL_Path) # Check if dll exists in same directory as executable.
+except:
+    print("PyD3XX ERROR: Did not find '" + _DLL_Path + "', EXITING.")
+    exit()
+_Print("Successfully loaded D2XX: '" + _LibraryFile + "'", PRINT_INFO_START, True)
+
+# ---| FTD2XX Python Function Implementations |---
+
+def FT_CreateDeviceInfoList() -> tuple[int, int]:
+    DeviceCount = ctypes.c_ulong(0)
+    Status = _DLL.FT_CreateDeviceInfoList(ctypes.byref(DeviceCount))
+    return Status, DeviceCount.value # Device count is converted to a Python int.
+
+def FT_GetDeviceInfoList(DeviceCount: int) -> tuple[int, list[FT_Device]] | tuple[int, str]:
+    Status = FT_OK
+    DeviceCount = ctypes.c_ulong(DeviceCount)
+    if(DeviceCount.value < 1):
+        _Print(FT_STATUS_STR[Status] + " | ERROR: DeviceCount IS LESS THAN 1.", PRINT_ERROR_MINOR, False)
+        return Status, "FT_OTHER_ERROR"
+    DeviceList = (_FT_DEVICE_LIST_INFO_NODE * DeviceCount.value)()
+    Handle = ctypes.c_void_p(0)
+    Status = _DLL.FT_GetDeviceInfoList(ctypes.byref(DeviceList), ctypes.byref(DeviceCount))
+    if(Status != FT_OK):
+        _Print(FT_STATUS_STR[Status] + " | ERROR: FAILED TO GET DEVICE INFO LIST.", PRINT_ERROR_MAJOR, False)
+        return Status, "FT_OTHER_ERROR"
+    ReturnDeviceList = []
+    for i in range(DeviceCount.value):
+        ReturnDeviceList.append(_CreateDevice())
+        ReturnDeviceList[i].Handle = "FT_OTHER_ERROR"
+        ReturnDeviceList[i].Flags = DeviceList[i].Flags
+        ReturnDeviceList[i].Type = DeviceList[i].Type
+        ReturnDeviceList[i].ID = DeviceList[i].ID
+        ReturnDeviceList[i].LocID = DeviceList[i].LocID
+        ReturnDeviceList[i].SerialNumber = DeviceList[i].SerialNumber.decode("utf-8")
+        ReturnDeviceList[i].Description = DeviceList[i].Description.decode("utf-8")
+    return Status, ReturnDeviceList
+
+def FT_Open(Index: int, Device: FT_Device) -> int:
+    Status = FT_OTHER_ERROR
+    if(not(isinstance(Device, FT_Device))):
+        _Print("FT_Open(), did not get an FT_Device!", PRINT_ERROR_MAJOR, False)
+    elif(not(isinstance(Device._Handle, ctypes.c_void_p))):
+        _Print("FT_Open(), got an uninitialized or broken FT_Device object!", PRINT_ERROR_MAJOR, False)
+    else:
+        Status = _DLL.FT_Open(ctypes.c_int(Index), ctypes.byref(Device._Handle))
+        Device.Handle = Device._Handle.value
+    return Status
+
+def FT_Close(Device: FT_Device) -> int:
+    Status = FT_OTHER_ERROR
+    if(not(isinstance(Device, FT_Device))):
+        _Print("FT_Close(), did not get an FT_Device!", PRINT_ERROR_MAJOR, False)
+    elif(not(isinstance(Device._Handle, ctypes.c_void_p))):
+        _Print("FT_Close(), got an uninitialized or broken FT_Device object!", PRINT_ERROR_MAJOR, False)
+    else:
+        Status = _DLL.FT_Close(Device._Handle)
+        Device.Handle = "FT_OTHER_ERROR"
+    return Status
+
+def FT_SetBitMode(Device: FT_Device, Mask: int, Mode: int) -> int:
+    Status = FT_OTHER_ERROR
+    Status = _DLL.FT_SetBitMode(Device._Handle, ctypes.c_char(Mask), ctypes.c_char(Mode))
+    return Status
+
+def FT_Write(Device: FT_Device, Buffer: FT_Buffer, BufferLength: int) -> tuple[int, int]:
+    Status = FT_OTHER_ERROR
+    if(isinstance(Buffer._RawAddress, FT_Buffer)):
+        _Print("FT_Write(), was not given expected FT_Buffer.", PRINT_ERROR_MAJOR, False)
+        return Status, 0
+    BytesTransferred = ctypes.wintypes.DWORD(0)
+    Status = _DLL.FT_Write(Device._Handle,
+                            ctypes.byref(Buffer._RawAddress),
+                            BufferLength,
+                            ctypes.byref(BytesTransferred))
+    return Status, BytesTransferred.value
+
+def FT_Read(Device: FT_Device, BufferLength: int) -> tuple[int, FT_Buffer, int]:
+    Status = FT_OTHER_ERROR
+    Buffer = FT_Buffer()
+    Buffer._RawAddress = ctypes.c_buffer(BufferLength)
+    Buffer._Length = BufferLength
+    BytesTransferred = ctypes.c_ulong(0)
+    Status = _DLL.FT_Read(Device._Handle,
+                            ctypes.byref(Buffer._RawAddress),
+                            BufferLength,
+                            ctypes.byref(BytesTransferred))
+    return Status, Buffer, BytesTransferred.value
+    

pyd2xx-0.0.1/src/PyD2XX/__init__.py

@@ -0,0 +1,3 @@
+from PyD2XX.PyD2XX import *
+from PyD2XX.PyD2XX import _LibraryFile
+from PyD2XX.PyD2XX import _Print