{"id":20587783,"url":"https://github.com/sparkfun/qwiic_nau7802_py","last_synced_at":"2026-03-04T07:32:28.008Z","repository":{"id":213338670,"uuid":"310707999","full_name":"sparkfun/qwiic_nau7802_py","owner":"sparkfun","description":"Python module for the Nuvoton NAU7802 24-bit dual-channel ADC for (Wheatstone) bridge sensors","archived":false,"fork":false,"pushed_at":"2025-03-19T19:32:54.000Z","size":6563,"stargazers_count":1,"open_issues_count":2,"forks_count":2,"subscribers_count":3,"default_branch":"main","last_synced_at":"2025-04-09T08:51:20.109Z","etag":null,"topics":["circuitpython","micropython","python","sparkfun","sparkfun-python"],"latest_commit_sha":null,"homepage":"http://docs.sparkfun.com/qwiic_nau7802_py/","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/sparkfun.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2020-11-06T21:20:31.000Z","updated_at":"2025-03-21T11:02:51.000Z","dependencies_parsed_at":"2023-12-20T14:33:30.596Z","dependency_job_id":"d30ab619-be4e-4a98-9b64-27ff0cade0e7","html_url":"https://github.com/sparkfun/qwiic_nau7802_py","commit_stats":null,"previous_names":["sparkfun/qwiic_nau7802_py"],"tags_count":4,"template":false,"template_full_name":null,"purl":"pkg:github/sparkfun/qwiic_nau7802_py","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/sparkfun%2Fqwiic_nau7802_py","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/sparkfun%2Fqwiic_nau7802_py/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/sparkfun%2Fqwiic_nau7802_py/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/sparkfun%2Fqwiic_nau7802_py/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/sparkfun","download_url":"https://codeload.github.com/sparkfun/qwiic_nau7802_py/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/sparkfun%2Fqwiic_nau7802_py/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":30075427,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-03-04T05:31:57.858Z","status":"ssl_error","status_checked_at":"2026-03-04T05:31:38.462Z","response_time":59,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["circuitpython","micropython","python","sparkfun","sparkfun-python"],"created_at":"2024-11-16T07:19:00.310Z","updated_at":"2026-03-04T07:32:27.977Z","avatar_url":"https://github.com/sparkfun.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"Qwiic_Template_Py\n==================\n\u003cp align=\"center\"\u003e\n   \u003cimg src=\"https://cdn.sparkfun.com/assets/custom_pages/2/7/2/qwiic-logo-registered.jpg\"  width=200\u003e  \n   \u003cimg src=\"https://www.python.org/static/community_logos/python-logo-master-v3-TM.png\"  width=240\u003e   \n\u003c/p\u003e\n\n\nThis is a template repository and associated documentation that outlines how to publish and maintain a python package \nfor the SparkFun Qwiic ecosystem.\n\nThis repository defines the general structure of a repository and details the role of each file/location in the repository. \nAdditionally, the use of ReadTheDocs and PyPi are outlined. \n\nThe general structure implemented follows the guidelines set forth in the python packaging structure and tools. While this document provides a high-level overview of SparkFun's implementation of a python project, details of this process and structure can be found in the [Packaging Python Projects](https://packaging.python.org/tutorials/packaging-projects/) document provided by the Python Foundation. \n\nFor details and example use of the described structure, please review the existing python projects for the Qwiic system. \nExamples Include:\n* [Qwiic_CCS811_Py - An example of a repository for a single file, python module](https://github.com/sparkfun/Qwiic_CCS811_Py)\n* [Qwiic_Micro_OLED_Py - An example of a python package, that includes resource files](https://github.com/sparkfun/Qwiic_Micro_OLED_Py)\n* [Qwiic_Py - the overall package for the Qwiic python system](https://github.com/sparkfun/Qwiic_Py)\n\nRepository Structure\n---------------------\n\nThe general structure of a Qwiic Python repository is as follows\n\n```\nQwiic_Template_Py/\n   +--- docs/\n   |       `--- ... files to support automatic documentation creation via readthedocs.org\n   |\n   +--- examples/\n   |       `--- ... example files for the package\n   |\n   +--- .readthedocs.yml  - configuration file for readthedocs\n   +--- DESCRIPTION.rst   - Contains the RST formatted description for the package. Used when building the installer package\n   +--- LICENSE           - The license for the package. Currently using MIT\n   +--- README.md         - The GitHub markdown formatted readme for the package\n   +--- setup.cfg         - Configuration details used when building the installer package.\n   +--- setup.py          - The python script used to define and build the python installer package.\n   |\n   +--- qwiic_\u003cmod\u003e.py.   - If a module (single file implementation), the implementation source code file.\n   |\n   or\n   |\n   `--- qwiic_package/    - If a package (directory that contains the implementation) the name of the package\n        `---  ... implementation files.\n   \n\n```\nImplementation\n-----------------\nTo keep the implementation simple and minimize resource needs, there are few design requirements when implementing a new Qwiic I2C driver. Each driver implements a class that encapsulates all interations with the underlying I2C device. This class implements a simple interface that enables the higher-level functionality provided by the overarching [Qwiic package](https://github.com/sparkfun/Qwiic_Py).\n\nThe specific implementation requirements are as follows\n\n### Device Class\nEach development driver package implements a class that encapsulates all interactions with this device. \n\n#### Class Name\nThe class name should be a **CamelCase** version of the package name. This naming schema is used by future automation functionality and follows common python methodologies\n\n```\n     qwiic_bme280.          -\u003e QwiicBme280\n     qwiic_micro_oled       -\u003e QwiicMicroOled\n     qwiic_scmd             -\u003e QwiicScmd\n     qwiic_my_super_board.  -\u003e QwiicMySuperBoard\n```\n\nAn example of a class declaration (note the use and location of the class docstring):\n```python\nclass QwiicScmd(object):\n\t\"\"\"\n\tQwiicScmd\n\n\t\t:param address: The I2C address to use for the device. \n\t\t\t\t\t\tIf not provided, the default address is used.\n\t\t:param i2c_driver: An existing i2c driver object. If not provided \n\t\t\t\t\t\ta driver object is created. \n\t\t:return: The Serial Control Motor Driver device object.\n\t\t:rtype: Object\n\t\"\"\"\n```\n\n#### Class Variables\nTo support the dynamic discovery and enumeration of Qwiic boards by the [Qwiic package](https://github.com/sparkfun/Qwiic_Py), each object implements a set of class variables. This allows the Qwiic package to inspect these values at runtime without having to instantiate an actual object. \n\nThese variables are:\n\n| Class Variable Name| Description|\n|----|----|\n|**device_name**      |      - Set to the human-readable name of the device|\n|**available_addresses**|   - Set to an array of the I2C addresses this device supports. The first address is the default|\n\nThese values are set outside of any class method, by convention they are placed right after the class declaration statement. \n\nExample:\n```python\nclass QwiicScmd(object):\n\t\"\"\"\n\tQwiicScmd\n\n\t\t:param address: The I2C address to use for the device. \n\t\t\t\t\t\tIf not provided, the default address is used.\n\t\t:param i2c_driver: An existing i2c driver object. If not provided \n\t\t\t\t\t\ta driver object is created. \n\t\t:return: The Serial Control Motor Driver device object.\n\t\t:rtype: Object\n\t\"\"\"\n\tdevice_name = \"Qwiic Serial Control Motor Driver\"\n\t\n        # note, the first address is the default I2C address.\n\tavailable_addresses = [0x58, 0x59, 0x5A, 0x5C]\n```\n#### The Constructor \nThe Qwiic package expects the constructor of the class to implement the following signature:\n```\ndef __init__(self, address=None, i2c_driver=None):\n```\nThe method supports the following parameters:\n\n|Parameter | Description |\n|----|----|\n|address| The I2C address to use for the device. If not provided, the default address is used|\n|i2c_driver| An existing Qwiic I2C device object. If not provided, the class should create an instance of driver|\n\nThe initial body of the constructor handles these parameters - setting the I2C address and constructing a I2C driver if needed. The following object constructor provides a *boilerplate* implementation for this functionality. \n\n```python\ndef __init__(self, address=None, i2c_driver=None):\n\n\n\t\t# Did the user specify an I2C address?\n\t\tself.address = address if address != None else self.available_addresses[0]\n\n\t\t# load the I2C driver if one isn't provided\n\n\t\tif i2c_driver == None:\n\t\t\tself._i2c = qwiic_i2c.getI2CDriver()\n\t\t\tif self._i2c == None:\n\t\t\t\tprint(\"Unable to load I2C driver for this platform.\")\n\t\t\t\treturn\n\t\telse:\n\t\t\tself._i2c = i2c_driver\n```\nNote - the docstring for the constructor is actually the docstring for the class.\n\n### Interface Conventions\nWhile not strictly required, the following conventions and patterns are used for qwiic driver implementations\n\n#### Device Constants as Class Attributes\nA standard methodology for I2C device implementations is to define constants (#defines in C/C++) for I2C interaction values for a device. For Qwiic python modules these values are defined as capitalized attributes and either placed as file attributes or class attributes on the driver class. \n\nThe convention is to implement any attributes required for user interaction as class attributes. Any internal values are created as file/modules attributes. \n\n#### is_connected() Method\nEach class implements an ```is_connected()``` method that returns True the specific Qwiic device is connect to the system. \n\nThis is a standard method, that often uses the following implementation pattern.\n```python\ndef is_connected(self):\n\t\t\"\"\" \n\t\t\tDetermine if a SCMD device is connected to the system.\n\n\t\t\t:return: True if the device is connected, otherwise False.\n\t\t\t:rtype: bool\n\n\t\t\"\"\"\n\t\treturn qwiic_i2c.isDeviceConnected(self.address)\n\t\n# expose as a property\nconnected = property(is_connected)\n```\n\nAdditionally, the method is exposed as a read-only attribute on the object. \n\n#### A begin() Method\nFollowing the pattern set by the Qwiic Arduino libraries, a begin() method is used to perform the actual initialization of the underlying I2C device. \n\nWhile each device implements device specific initialization logic, the signature of this method is as follows:\n```python\ndef begin(self):\n\t\t\"\"\" \n\t\t\tInitialize the operation of the SCMD module\n\n\t\t\t:return: Returns true of the initialization was successful, otherwise False.\n\t\t\t:rtype: bool\n\n\t\t\"\"\"\n```\n\n\nImplementation Structure\n-------------------------\nThere are two patterns of implementation for a package - a python module or a python package. \n\nTo the end-user a package or module looks the same, but the implementation within the repository is different. \n\n### Module\nA python module is nothing more than a single file that makes up the overall implementaiton for the package. \nThis file has the same name as the package being imported by the user. \n\nFor example, if a user imports a module named qwiic_module\n```python\nimport qwiic_module\n```\nThe file name would be ```qwiic_module.py``` and reside in the root of the repository.\n```\nQwiic_Module_Py/\n   +--- qwiic_module.py\n```\n\n### Package\nA python package is a folder that contains the implementation of the package. The folder can contain python source files, as well as any other resource needed for the property operation of the package.\n\nThe package directory is name is the name of the package. A file named ```__init__.py``` in the root directory of the package defines its entry/operation and lets python know that the directory implements a package.\n\nFor example, if the user imports a package named qwiic_package\n```python\nimport qwiic_package\n```\n\nThe structure of this implementation would be under a directory called ```qwiic_package``` in the repository\n\n```\nQwiic_Package_Py\n   +--- qwiic_package/\n           +--- __init__.py       - the entry point for the package implementation\n           |\n           +---  ... Any other file, directory or resource that makes up the package\n```\n\nNote: The souce of the implementation must be contain the [license attribution statement](#source-code-license-attribution).\n\nThe LICENSE File\n----------------\nThe file named [LICENSE](https://github.com/sparkfun/Qwiic_Template_Py/blob/master/LICENSE) contains the license for the repository. The name of the file, LICENSE, is used by other systems to identify which license the repository implements.\n\nFor example, in GitHub, when the contents of the file is viewed, the system will display details about the license and clearly indicate to the user what the license covers. \n\nThe SparkFun Qwiic python module implementations fall under the MIT license. \n\n### Source Code License Attribution\nEach source file distributed with one of our python packags/modules must include the proper license attribution in the entry comment section of the code. \n\nThe Qwiic Python packages are licensed using the MIT license and as such should include the following statement in the top/entry section of the code:\n```python\n#==================================================================================\n# Copyright (c) 2019 SparkFun Electronics\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy \n# of this software and associated documentation files (the \"Software\"), to deal \n# in the Software without restriction, including without limitation the rights \n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell \n# copies of the Software, and to permit persons to whom the Software is \n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all \n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR \n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, \n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER \n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, \n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE \n# SOFTWARE.\n#==================================================================================\n```\n\nInstaller/Package Creation\n--------------------------\nThe Qwiic Python components are packaged using standard python package/install tools, and hosted within the Python Package Index (pypy.org).\n\nWithin the repository, the files that makeup the package are the following:\n```\nQwiic_Example_Py\n   + DESCRIPTION.rst          - A high level description of the package\n   |\n   + setup.cfg                - Specific options/settings for the package tools \n   |\n   + setup.py                 - A python script that defines and builds the installer package\n\n```\n\n#### DESCRIPTION.rst\nThe file [DESCRIPTION.rst](https://github.com/sparkfun/Qwiic_Template_Py/blob/master/DESCRIPTION.rst) is a RST ([reStructured Text](https://gist.github.com/dupuy/1855764)) file that has a simple, high-level description of the package. When setup.py is executed, it reads the contents of this file and sets it as the description of the package. _(\\***Note:** The title should read **Qwiic** \u003cPackage Name\u003e and the number of `=` must be greater than the character length of the title.)_\n\n```\nQwiic \u003cExample Package Title\u003e\n=============================================\n```\n\n#### setup.cfg\nThe file [setup.cfg](https://github.com/sparkfun/Qwiic_Template_Py/blob/master/setup.cfg) contains options that the packaging tools use when creating the specific package. For the most part, the file in this template repo can be used. \n\n### setup.py\nThe file ```setup.py``` is a python script that is used to describe the package and build an install package. The file is used by the python package ```setuptools```, which is a collection of utilities that make it simple to build and distribute Python distributions. \n\nThis template repository contains an example ```setup.py``` file for review and an overview of the file contents are below. For details on the structure of the file, please review the [setup.py section](https://packaging.python.org/tutorials/packaging-projects/#creating-setup-py) in the Packaging Python Projects document. \n\n___Description Section___\n\nOne of the first sections in ```setup.py``` is reading in the contents of *DESCRIPTION.rst*. \n```python\nimport io\n\nhere = path.abspath(path.dirname(__file__))\n\n# get the log description\nwith io.open(path.join(here, \"DESCRIPTION.rst\"), encoding=\"utf-8\") as f:\n    long_description = f.read()\n```\nThis reads the contents of the description fine and places the resulting string into the variable ```long_description```. This variable is passed into the call to ```setup()``` using the *```long_description```* keyword parameter.\n\nNote: The ```io.open``` method is used to support *uft-8* file encoding in Python versions 2.7 and 3.*. \n\n___setuptools.setup( name=)___\n\nThis keyword is set to the name to publish the package under in PyPi.org and the name passed to the ```pip``` command for installing the package. _(\\***Note:** The package name should be in the form of `sparkfun_qwiic_\u003cpackage_name\u003e`.)_\n\nThe following command shows this value for the qwiic bme280:\n```python\nsetuptools.setup(\n    # ...\n    name='sparkfun_qwiic_bme280',\n    # ...\n   )\n```\n\n**NOTE:** For PyPi/Pip, underscores ```_``` and dashes ```-``` are interchangeable. \n\n___setuptools.setup( version=)___\n\nThis controls the package's release version on PyPI. _(\\***Note:** Start off with the lowest release value until the package is finalized; then, the version can get \"bumped up\" to `1.0.0`. When uploading a package to PyPI, the version number needs to be \"bumped up\" for any package changes to take into effect.)_\n\n```python\nsetuptools.setup(\n   # ...\n   # Versions should comply with PEP440.  For a discussion on single-sourcing\n   # the version across setup.py and the project code, see\n   # http://packaging.python.org/en/latest/tutorial.html#version\n   version='0.0.1',\n   #...\n```\n\n___setuptools.setup( description= and url=)___\n\nModify the description with the package's name and include the url for the associated product page.\n\n```python\nsetuptools.setup(\n   # ...\n    description='SparkFun Electronics qwiic \u003cpackage_name\u003e package',\n    long_description=long_description,\n\n    # The project's main homepage.\n    url='https://www.sparkfun.com/products/\u003cProduct Number\u003e',\n   #...\n```\n\n___setuptools.setup( install_requires=)___\n\nThe *```install_requires```* keyword arguement to ```setuptools.setup()``` is used to specify what other python packages this package depends on. \n\nAn example of this is the ```sparkfun-qwiic-i2c``` package, which all Qwiic board python packages use. An example of this from the Qwiic Proximity package ```setup()``` is as follows:\n```python\nsetuptools.setup(\n    # ...\n     \n    install_requires=['sparkfun_qwiic_i2c'],\n\n\t\t# ...\n   )\n```\n\nFor the overall Qwiic package, which depends on all driver packages, this parameter has the following form:\n```python\nsetuptools.setup(\n    # ...\n   setup_requires = ['sparkfun-qwiic-i2c']\n\n   # Use the dir names of the submodules in the ./qwiic/drives directory\n   sub_mods = os.listdir(here+os.sep+'qwiic/drivers')\n   for daDriver in sub_mods:\n      setup_requires.append('sparkfun-%s' % (daDriver.replace('_','-')))\n\n    # ...\n   )\n```\n\n___setuptools.setup(classifiers=[])___\n\nThe classifiers argument to ```setup()``` are attrbitues that describe the package and are used details specifics to the PyPi respository and users of the project. While a [detailed list of of valid classifier values](https://pypi.org/pypi?%3Aaction=list_classifiers) is available at pypy.org, the key values are the project maturity (is it Alpha, Beta, Production?) and what python versions are supported. \n\nThe example script has the following classifiers:\n```python\nsetuptools.setup(\n    # ...\n    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers\n    classifiers=[\n        # How mature is this project? Common values are\n        #   3 - Alpha\n        #   4 - Beta\n        #   5 - Production/Stable\n        'Development Status :: 5 - Production/Stable',\n\n        # Indicate who your project is intended for\n        'Intended Audience :: Developers',\n        'Topic :: Software Development :: Build Tools',\n\n        # Pick your license as you wish (should match \"license\" above)\n        'License :: OSI Approved :: MIT License',\n\n        # Specify the Python versions you support here. In particular, ensure\n        # that you indicate whether you support Python 2, Python 3 or both. \n        'Programming Language :: Python :: 2.7',\n        'Programming Language :: Python :: 3.5',\n        'Programming Language :: Python :: 3.6',\n        'Programming Language :: Python :: 3.7',\n   \n    ],\n    # ...\n   )\n```\n\nYou can see these detailed out on the SparkFun Qwiic package (sparkfun-qwiic) on the [PyPi.org repository.](https://pypi.org/project/sparkfun-qwiic/)\n\n___setuptools.setup(packages=[])___\n\nIf your repository defines one or more packages (directories), the names of these packages are provided to the ```packages``` keyboard argument to setuptools. Note: this is the directory/package name the user references in python code, not the package name used by PyPi - which can also contain additional keywords. \n\nFor the Qwiic package, this is just the Qwiic directory:\n```python\nsetuptools.setup(\n     # ...\n     \n    packages=['qwiic'],\n\n   # ...\n   )\n```\nor for the qwiic_micro_oled package, which includes a font subpackage:\n```python\nsetuptools.setup(\n     # ...\n     \n    packages=[\"qwiic_micro_oled\", \"qwiic_micro_oled/fonts\"],\n\n   # ...\n   )\n```\n___setuptools.setup(package_data={})___\n\nThe packaging system will include python files (```.py```) files by default. If the package includes non-python files, these are specified via the ```pacakge_data``` keyword argument, which takes a dictionary. \n\nThe provided dictionary key values are a specific location, and the value is the data files to include in the package. The data filenames can be specific names, or include wildcards. \n\nAn example of this is used in the qwiic_micro_oled package, which includes font data files, named using a ```.bin``` file extension. These data files are located in the ```./fonts``` subdirectory of the package repository.\n```python\nsetuptools.setup(\n     # ...\n     package_data={\n         \"qwiic_micro_oled/fonts\" : ['*.bin']\n    },\n\n   # ...\n   )\n```\n___setuptools.setup(py_modules=[])___\n\nIf the install package implements a module (source file) and not a python package (directory), the modules are specific to the ```setup()``` method call using the ```py_modules=[]``` keyword argument. The value of this keyword is an array that contains the names of the modules to include in the package. Note, the file suffix is not included in the provided names.  _(\\***Note:** The module name should be in the form of `\"qwiic_\u003cpackage_name\u003e\"`.)_\n\nFor the Qwiic BME280 package, which is implemented in a single file, the module is specified as follows:\n```python\nsetuptools.setup(\n   # ...\n    py_modules=[\"qwiic_bme280\"],\n   # ...\n   )\n```\n\nBuilding and Uploading the Package\n----------------------------------\n\nWhen ready to build and upload a package to pypi.org, the following setups are performed.\n\n#### Get an Account on PyPi.org\nYou'll need an account on PyPi.org - it's a simple sign up procedure.\n\nTo publish a new package, you can use this account. If you are updating or modifying an existing package, you'll need to be added as a *Maintainer* of the package by the package owner.\n\n#### Build the Package distributions\n\nTo build and upload the packages, make sure the required python packages are installed - **setuptools**, **twine**, and **wheel**. \n```sh\nsudo pip install setuptools twine wheel\n```\n\nBuild the distribution packages using the following commands (executing in the package root directory). First create a standard distribution:\n```sh\npython setup.py sdist \n```\nThen a distribution in the ```wheel``` format.\n```sh\npython setup.py bdist_wheel --universal\n```\nThese commands will create distribution package files and place them in the ```./dist``` subdirectory. \n\n### Upload the Package to PyPi.org\n\nThe ```twine``` command is used to upload the install packages to pypi.org. To upload the packages, use the following command:\n\n```sh\ntwine upload dist/*\n```\nThis command will prompt for the *username* and *password* for the pypi account to use for the upload.\n\nOnce the upload is completed, the packages are now available for use via the pip installer. \n\nNOTE: Your PyPi.org username and password can be specified in the file ```~/.pypirc``` instead of entering with each call to twine. The format of this file:\n\n```ini\n[pypi]\nusername = \u003cthe username\u003e\npassword = \u003cthe password\u003e\n```\nDocumentation Generation - ReadTheDocs.org\n------------------------------------------\n\nDetails of the documentation generation process are contained in the file [DOCUMENTATION.md](DOCUMENTATION.md)\n\nAdding the Module dependency  to the main Qwiic package, Qwiic_Py\n------------------------------------------------------------------\n\nAdding the Module dependency  to the main Qwiic package, Qwiic_Py \n\nThe overall Qwiic package, which is hosted in the Qwiic_Py repository, defines dependencies to all the SparkFun  Qwiic python packages. This is accomplished by adding modules to the repo as git submodules. \n\nNew drivers are added as git submodules in the Qwiic_Py/qwiic/drivers directory. \n\nNaming of the driver directory is important – it should map to the package name in PyPi, minus the initial ‘sparkfun-‘ name. \n\nSo for the BME280 package, which is defined in PyPi as ‘sparkfun-qwiic-bme280’, would be placed in a directory named ‘qwiic_bme280’ in the drivers folder. \n\nTo add a driver/package to the Qwiic repository, do the following steps:\n* Clone the Qwiic repository \n```git clone git@github.com:sparkfun/Qwiic_Py.git```\n* Move to the drivers directory\n```cd Qwiic_Py/qwiic/drivers```\n* Add the submodule, using the following command\n``` git submodule add \u003crepo to add\u003e \u003cname of driver folder\u003e```\n\nExample for the Titan GPS driver\n``` git submodule add git@github.com:sparkfun/Qwiic_Titan_Gps_Py.git qwiic_titan_gps ```\n\n_Note, if you get a failure due to permissions, you may need to use the complete URL for the \\\u003crepo to add\\\u003e. (\\***Note:** Don't forget to include the submodule name (`qwiic_\u003cpackage_name\u003e`) after the link for the repo.)_\n\nExample for the Titan GPS driver (with full URL)\n``` git submodule add https://github.com/sparkfun/Qwiic_Titan_Gps_Py qwiic_titan_gps ```\n\n\n* Add this new folder to the repo, commit it and push to GitHub \n\nOnce completed, the Qwiic_Py package must be updated and uploaded to PyPi. \n\n* Bump up the version in the setup.py file. This step defines package dependencies for everything contained in the drivers subfolder, including the newly added submodule. \n* Follow the above package build and upload steps\n\nOnce completed, an update/install of the sparkfun-qwiic package will include the new submodule\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsparkfun%2Fqwiic_nau7802_py","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fsparkfun%2Fqwiic_nau7802_py","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsparkfun%2Fqwiic_nau7802_py/lists"}