Saravanan666/pypi-org huggingface dataset:
Package: arc-utils
# README #### What is this repository for? ###
* A collection of (mostly) arcpy related utilities for use within ArcGIS Desktop (Python 2.7), or ArcGIS Pro (Python 3) as well where possible.
Shortcuts for accessing elements of a map document, performing various data discovery tasks on a table or gdb### How do I get set up? ###To install the utilities:pip install arc_utilsClone the repo to your machine and add the path to the python installhttps://docs.python.org/2/tutorial/modules.html#the-module-search-pathOptionally, you can copy the folder to the site-packages in the ESRI python install directory, or add a .pth file to the site-packages folder pointing to the clone directory.To use the utilities:in the python window in ArcMap/ArcCatalog/Pro`python import arc_utils as au `typingau.will now reveal the modules and functions available to you if you have autocomplete onDepends on arcpy (only available with Esri license)### Example usage ###import arc_utils as autbl = au.table.TableObj(path to featureclass)# list all fieldsprint(tbl.fields)mxd_doc = au.mxd.MxdObj(“CURRENT”)mxd_doc.layer_names_array >> [‘layer1’,’layer2’]pro_doc = au.aprx.AprxObj(“CURRENT”)pro_doc.maps >> [<arcpy._mp.Map object at 0x000001A4AECBF108>, <arcpy._mp.Map object at 0x000001A4AEBB6608>]pro_doc.maps[0].name >> ‘Map’### Contribution guidelines ###Contributions welcomed, this is a starting point for various utilities that I think could be useful within Arc.
Package: arc-vector-python
arc-vector-pythonPython library and client for arc-vector databaseInstallation// remote install
pip install arc-vector-python

// local install by package
pip install arc_vector_python-1.6.2.tar.gzFeaturesType hints for all API methodsLocal mode - use same API without running serverREST and gRPC supportMinimal dependenciesConnect to ArcVector ServerTo connect to Qdrant server, simply specify host and port:from arc_vector_client import ArcVectorClient
from arc_vector_client.models import Distance, VectorParams
# REST
client = ArcVectorClient(url="http://localhost:8333")
# gRPC
client = ArcVectorClient(host="localhost", grpc_port=8334, prefer_grpc=True)Async clientStarting from version 1.6.2, all python client methods are available in async version.To use it, just importAsyncArcVectorClientinstead ofArcVectorClient:fromarc_vector_clientimportAsyncArcVectorClient,modelsimportnumpyasnpimportasyncioasyncdefmain():# Your async code using ArcVectorClient might be put hereclient=AsyncArcVectorClient(url="http://localhost:8333")# client = AsyncArcVectorClient(host="localhost", grpc_port=8334, prefer_grpc=True)awaitclient.create_collection(collection_name="my_collection",vectors_config=models.VectorParams(size=10,distance=models.Distance.COSINE),)awaitclient.upsert(collection_name="my_collection",points=[models.PointStruct(id=i,vector=np.random.rand(10).tolist(),)foriinrange(100)],)res=awaitclient.search(collection_name="my_collection",query_vector=np.random.rand(10).tolist(),# type: ignorelimit=10,)print(res)asyncio.run(main())Both, gRPC and REST API are supported in async mode.
More examples can be foundhere.
Package: ard
Agnostic Raw Data (ARD) for PythonWhat is ARD? Seehere.The latest stable release of this library isavailable on PyPi:python -m pip install ardThis library has three main features:Allows you to easily transmit ARD in several formats: YAML, JSON, XML, and
CBOR. Supports both encoding and decoding. Included is anardconvCLI
tool that can convert between all formats.Enable support for decoding YAML with complex keys. As it stands, the
otherwise excellentruamel.yamllibrary will choke on complex keys.Support for ARD-compatible extensions to JSON (CJSON). This allows for
round-tripping ARD through JSON without losing type information, including
support for integers, byte arrays, and maps with non-string keys.Python'sdictdoes not support un-hashable keys, making it difficult to work
with complex keys. For this reason we provide theard.Mapclass, which does
support un-hashable keys and is otherwise a drop-in replacement fordict. It
will be used automatically when decoding, if necessary.Documentation is a work in progress! For now check outtest.pyfor example use.
Package: arda
ardaPython library for Tolkien-related data processingThis project is in its early stages and currently just has two things.Firstly, an initial implementation ofYearandYearDeltaclasses for
dealing with Ages and the beginnings of a Shire Calendar classShireDate.Seetest.rstfor an example.Secondly, a syllabification library for breaking Elvish words into
syllables and calculating where the stress should go.Seepron_test.rstfor an example.DevelopmentInstall the dev dependencies inPipfile.Then runtest.shto test orlint.shto lint.
Package: ardana-packager
#
# (c) Copyright 2015 Hewlett Packard Enterprise Development LP
# (c) Copyright 2017 SUSE LLC
#
# Licensed under the Apache License, Version 2.0 (the “License”); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#http://www.apache.org/licenses/LICENSE-2.0#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an “AS IS” BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
install_package application in support of Ardana
Package: ard-em
# ARD EM
ARD (Automatic Relevance Determination) EM implementation on Python.
The classical EM-algorithm for reconstructing a mixture of normal distributions does not allow to determine the amount of components of the mixture. The ARD EM implementation suggests algorithm for automatically determining the number of components ARD EM, based on the method of relevant vectors. The idea of the algorithm is to use at the initial stage of a knowingly excessive amount of the components of the mixture with further determination of the relevant components by maximizing
validity. Experiments on model problems show that the number of found clusters either coincides with the true one, or slightly
excels him. In addition, clustering with ARD EM is closer to the true than the analogs based on sliding control and
character of the minimum description length. It’s EM algorithm with automatic determination of number of components. It’s powerful and fast algorithm for gaussian mixture learning and clustering with unknown number of components.# Implementation
The implemented [GaussianMixtureARD](ard_em.py) class has the same interface as SkLearn’s [GaussianMixture](http://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture) one, but with 3 additional parameters:`pythoninit_components="sqrt"# Initial number of components. sqrt(N) if "sqrt" alpha_bound=1e3 # Drop all components with weight_reg (alpha) > alpha_boundweight_bound=1e-3# Drop all components with weight < weight_bound `and withoutn_componentsone.# Installation` pip installgit+https://github.com/Leensman/ard-em.git`## Example`python from ard_em import GaussianMixtureARD gmm = GaussianMixtureARD() gmm = gmm.fit(X)print('Bayesianinformation criterion: ', gmm.bic(X)) best_n_components = gmm.n_componentsprint('Bestnumber of components: ', best_n_components) gmm.predict(X) `For more examples go to [GaussianMixture.ipynb](https://github.com/Leensman/ard-em/blob/master/ard-em/examples/Gaussian%20mixture.ipynb)## Links
[Original paper](http://www.machinelearning.ru/wiki/images/d/dc/Vetrov-ArdEm-JVMMF-2009.pdf)## Author
Artem Ryzhikov, LAMBDA laboratory, Higher School of Economics, Yandex School of Data AnalysisE-mail:artemryzhikoff@yandex.ruLinkedin:https://www.linkedin.com/in/artem-ryzhikov-2b6308103/HSE profile:https://www.hse.ru/org/persons/190912317
Package: ardent
ARDENTAffine andRegularizedDEformativeNumericTransform (ARDENT) is a Python package for performing automated image registration using LDDMM.ARDENT stands out for its ability to predict and correct for artifacts and image nonuniformity, perform registrations across image modalities, ease of use, and other features in development.OverviewDocumentationSystem RequirementsInstallation GuideLicenseOverviewExperimental neuroscience produces a stunning amount of imaging data from light or electron microscopy, MRI, and other 3D modalities. To be of real use these datasets must be interpreted with respect to each other and to refined standards: well-characterized image datasets called atlases. To build these interpretations, dense spatial alignments must be computed. This process is known as image registration, in which one image is optimally deformed, or flowed, until it aligns with another. Accurate registration is challenged by the large scale of imaging data and the heterogeneity across species scales and modalities. Current tools can perform well on very standard images but perform poorly on data with various imperfections. This restricts our ability to analyze data from novel experiments performed in a majority of labs.ARDENT is an accessible pure-python image registration package in development with these neuroimaging challenges in mind.DocumentationThe official documentation with usage is athttps://ardent.neurodata.io/Please visit thetutorial sectionin the official website for more in-depth usage.System requirementsHardware requirementsARDENTpackage requires only a standard computer with enough RAM to support the in-memory operations.Python RequirementsThis package is written for Python3. Currently, it is supported for Python 3.6.Python DependenciesARDENTmainly depends on the Python scientific stack with the notable addition of PyTorch. However, this is pending deprecation.numpy
matplotlib
scipy
scikit-learn
simpleitk
nibabel
nilearn
pytorchInstallation GuideInstall from pippip install ardentInstall from Githubgit clone https://github.com/neurodata/ardent
cd ardent
python3 setup.py installLicenseThis project is covered under theApache 2.0 License.
Package: ardicsrtcollector
ArdicSrtCollectorArdicSrtCollector has been developed to generate the Turkish speech recognition dataset. As parameters, it takes a txt file consisting of the links of these Youtube videos and a folder name to store the files to be created. For each youtube video URL, it downloads the audio file,  extracts subtitles as theSRT format, and saves as two new files to the disk. Then it cropped (usingFFMPEG) the audio file according to the start and end time of each subtitle and creates a new audio file, and at the same time saves the current subtitle as a new txt file.InstallationInstallffmpeg.(it is re)Run$ pip install ardicsrtcollector.Usage1- From the terminalardicsrtcollector [-h] [-sv SAVE_PATH] -ufp URL_FILE_PATH

To convert the Youtube URL to mp3 and srt file.

optional arguments:
  -h, --help            show this help message and exit
  -sv SAVE_PATH, --save_path SAVE_PATH
                        Path to save converted files (default: downloads_convert)
  -ufp URL_FILE_PATH, --url_file_path URL_FILE_PATH
                        A file which contains youtube URLsExampleRun on terminal :ardicsrtcollector -ufp urls.txt2- Using it by importing as a package like the one below.from ardicsrtcollector.youtube_srt_mp3 import YoutubeSrtMp3

YoutubeSrtMp3(urls_file_path="urls.txt", save_dir="save_path").convert()The content of the file containing the URLs should be as follows.https://www.youtube.com/watch?v=ENwtC8LgPcw
https://www.youtube.com/watch?v=ENwtC8LgPcw
...LicenseApache License 2.0
Package: ardilla
ardillaArdilla (pronouncedahr-dee-yah) means "SQuirreL" in spanish.This library aims to be a simple way to add an SQLite database and
basic C.R.U.D. methods to python applications.
It uses pydantic for data validation and supports a sync engine as well
as an async (aiosqlite) version.Who and what is this forThis library is well suited for developers seeking to incorporate SQLite into their python applications to use simple C.R.U.D. methods.
It excels in its simplicity and ease of implementation while it may not be suitable for those who require more complex querying, intricate relationships or top performance.For developers who desire more advanced features, there are other libraries available, such astortoise-orm,sqlalchemy,ponyorpeewee.LinksFind Ardilla's source codehereDocumentation can be accessedhereinstallInstall lastest release from PyPipipinstall-Uardilla
pipinstall-Uardilla[async]pipinstall-Uardilla[dev]async instaslls aiosqlitedev installs formatting and testing dependenciesOr install the lastest changes directly from githubpipinstallgit+https://github.com/chrisdewa/ardilla.git
pipinstallgit+https://github.com/chrisdewa/ardilla.git#egg=ardilla[async]pipinstallgit+https://github.com/chrisdewa/ardilla.git#egg=ardilla[dev]How to usefromardillaimportEngine,Model,CrudfrompydanticimportFieldclassUser(Model):id:int=Field(primary=True,autoincrement=True)name:strage:intdefmain():withEngine('db.sqlite')asengine:user=crud.get_or_none(id=1)# user with id of 1user2,was_created=crud.get_or_create(id=2,name='chris',age=35)users=crud.get_many(name='chris')# all users named chrisuser3=User(id=3,name='moni',age=35)user.age+=1# it's her birthdaycrud.save_one(user3)crud.save_many(user,user2,user3)Supported CRUD methods:crud.insertInserts a record, rises errors if there's a conflictcrud.insert_or_ignoreInserts a record or silently ignores if it already existscrud.save_oneupserts an objectcrud.save_manyupserts many objectscrud.get_allequivalent toSELECT * FROM tablenamecrud.get_manyreturns all the objects that meet criteriacrud.get_or_createreturns an tuple of the object and a bool, True if the object was newly createdcrud.get_or_noneReturns the first object meeting criteria if anycrud.delete_oneDeletes an objectcrud.delete_manyDeletes many objectsExamples:A simpleFastAPIapplicationA reputation based discordbotbasic usagebasic usage with foreign keys
Package: ardu-acqua-visual
StatusThis project will probably never leave the status of:
Development - Alpha/Beta/WhateverAs I started this project, I installed python-virtual from
the debian apt repo (as I have both a debian-desktop and
a raspbian-develbox).
This is great for security, but not that great for
feature coverage…Now I am starting to play around with IPython and Jupyter and
use vpython installed through pip - but still, for the arduino
project, I will probably use both tracks in parallel for some
time..Dependencies, RequirementsDebian/Raspianpython-visualPython 2tested against: 2.7see requrements.txt for further dependenciesBasic IdeaJust for fun..For the flussbad-berlin.de project we want to visualize the
sensor values in a very basic and inexpensive way. So I just
got a little 5” touchscreen for the raspberry pi, which is
connected to the arduino, which is collecting sensor data.
I then put
the whole stuff into an old wooden wine box…This is just a first test to see whether the raspberry pi is
not getting too busy..OutlookReally nice to have would be a vpython7 based collection
of objects, that could be loaded based on a JSON config
to visualize a certain sensor setup…
Package: arducomm
Host-side ArduComm python library and examplesThis is the host-side library implementation of ArduComm, written in Python. In addition to the library's source code, different examples and tests are provided inexamplesandtest.InstallationPYPI installationThe easiest way to install the package is usingpip:python3-mpipinstallarducommManual installationAlternatively, this package can also be manually installed using Python'sbuildmodule andpip.First, install thebuildpackage if this hasn't been done before:python3-mpipinstallbuildThen, build the package and install it with pip:python3-mbuild
python3-mpipinstalldist/arducomm-*.whl--force-reinstallHow to useThe classArduCommis provided in the package and can be used to send and receive data. A callback function must be provided to process the received messages. Note that this implementation handles the incoming messages in a different thread, so there are no reading methods. The provided callback will be called when a new message is available.fromarducommimportArduCommdefrecv_callback(command,payload):print(F"Command received:{command}")print(F"Payload:\n{payload}")comms=ArduComm(recv_callback,port='/dev/ttyUSB0',baudrate=57600)comms.start()# Open the serial port# Use comms object...comms.stop()# Close the serial portHow to send dataThe functionsend(command, payload)can be used to send a message with the given command and payload. The payload must be a list of integers, a bytearray, or a bytes object.comms.send(0x07)# Send command 0x07 with no payloadcomms.send(0x03,[55,50])# Send command 0x03 with payload bytes [55, 50]SerializationIn order to work with payloads containing other types than pure bytes (aka uint8_t, aka unsigned char), these types must be serialized (converted to bytes) before being transmitted. Similarly, the array of bytes that is received in the payload must be parsed (deserialized) to reconstruct these types.To this end, a serialization module is also included in this library, following the implementation of the Arduino library, with support for basic types (char, str, uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, and float). Additional "complex" types are also defined in the types directory to provide more options with types such as 2D and 3D vectors, quaternions, or 2D/3D poses.You can find the full list of supported types and how to serialize/parse them inserialization_testandparser_test.Finally, you can also define your own types and use the provided serialization functions as it is done in thecustom_typeexample.
Package: arduiglitch
This package contains all the companion scripts required to run the Jupyterlab
notebooks of the Arduiglitch voltage glitch training developed by the
hardware security department (SAS) of l’École des Mines de Saint-Étienne.Repackage a local versionThe packagessetuptoolsandbuildare required to repackage the module.
They should be installed when updating withpipenv update.Thepyproject.tomlcontains all the configuration for the packaging process.
To build the package execute the following
commands from the root of the repository :pipenvshellpython-mbuildIf the packaging process went well, the module wheel should be located indist/`.To install this local version in a project, usePipenvand specify the path to
the.whlfile as follows:pipenvuninstallarduiglitchpipenvinstallrelative/path/to/arduiglitch/dist/arduiglitch-*.*.*-*-*-*.whlFor later local updates, theuninstallPipenvcommand prevents the use of
a cached version in case the version number
of the new version is the same as the current one.It is advised to change the version number in thepyproject.tomlfile after
each build. In such case, the path to the new module wheel needs to be adjusted
in thePipfileand onlypipenv updateis required to update.LicenseGNU General Public License version 3For more information, see theLICENSEfile at the root of the project.
Package: arduino-cli-cmake-wrapper
Arduino Cmake toolchain leveragingarduino-clivia python wrapper script.
It does not intend to replace thearduino-clitool, nor is it intended to be a full featured IDE-like solution.This project seeks to programmatically scrape up the necessary parts of the compile and link calls from thearduino-clitool, set CMake variables, and allow a CMake project to roughly emulate the Arduino compile process.The goal is to make it possible to leverge the Arduino libraries in a CMake-bound framework, for Arduino supported targets.
If you just want to compile a normal Arduino project from the command line, skip this project and CMake altogether and just use thearduino-clias intended.On the other hand, if you are trying to use a CMake-bound project as the primary development process, you need a way to extract the working compile process from the Arduino IDE and reformat it into a CMake Toolchain.E.g.: To compile anF Primeproject for an Arduino target using Arduino libraries, you need a shim like this to avoid hard dependence on the exact version or Arduino, Arduino Core, and the specific versions of installed libraries.🚀 InstallationMost typically, the cmake tooling is included as a git submodule in your project, or it is
included as an external project dependency.  If you want to install the python wrapper
directly, it can be done like this:pip install arduino-cli-cmake-wrapperYou can also install the in-development version with:pip install https://github.com/SterlingPeet/arduino-cli-cmake-wrapper/archive/main.zip📝 DocumentationDuring initial development, documentation is sparse.
It should be set up on readthedocs when the project is mature.https://arduino-cli-cmake-wrapper.readthedocs.io/🤝 Contributing and DevelopmentIf you are working on developing the software, head on over to theDeveloper Notespage for orientation and quick reference.
You can also take a look at theContributing Guide.🌎 Similar ProjectsThis project was not created in a vacuum.
Here is a list of projects that came before this one and why they are different or not appropriate.Arduino CMake: Original project to compile for Arduino in CMake, abandoned circa 2014Arduino-CMake NG: Next Generation Arduino CMake tool, abandoned circa 2018,officially abandoned in 2020Arduino CMake Toolchain: Named successor to NG, Abandoned almost immediately thereafter, circa 2020Arduino AVR CMake: AVR-only CMake toolchain with support for VScode, intended as a templateas explained on the Arduino forumChangelogv0.0.0 (2022-11-09)🎉 Other🎉 Initial Commit. [Sterling Peet]
Package: arduino_device
This Python package creates a class named ArduinoDevice, which
contains an instance of serial_interface.SerialInterface and adds methods
to it, like auto discovery of available Arduinos in Linux, Windows,
and Mac OS X. This class automatically creates methods from available
functions reported by the Arduino when it is running the appropriate
firmware.Authors:Peter Polidoro <polidorop@janelia.hhmi.org>License:BSDExample Usage:from arduino_device import ArduinoDevice
dev = ArduinoDevice()
dev = ArduinoDevice() # Automatically finds device if one available
dev = ArduinoDevice('/dev/ttyACM0') # Linux
dev = ArduinoDevice('/dev/tty.usbmodem262471') # Mac OS X
dev = ArduinoDevice('COM3') # Windows
dev.get_commands()
devs = ArduinoDevices()  # Automatically finds all available devices
devs.get_devices_info()
dev = devs[0]
Package: arduino-exporter
Arduino Prometheus ExporterYou can run this exporter on a device (PC or Raspberry PI) connected to an arduino. The exporter will listen to messages sent over the serial port and update the metrics exposed to prometheus.
I used this project to visualize and trigger alerts for a lot of sensors values like sound, temperature and water level … etcTo use the exporter, follow the following steps:Create a python virtual environment.$ python3 -m venv venv
$ source venv/bin/activateInstall arduino-exporter package with pip.$ pip install arduino-exporterTo run the arduino exporter process. You can use systemd to run the process on PC or Raspberry PI. The serial port value can be retrieved from arduino IDE.$ arduino_exporter server run -s $serial_port -p $http_port
$ arduino_exporter server run -s /dev/cu.usbmodem14101 -p 8000Upload a sketch to the arduino to send the metrics to the serial port.#define LED 13

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
  Serial.write("{\"type\": \"gauge\", \"name\": \"room_temp\", \"help\": \"the room temperature.\", \"method\": \"set\", \"value\": 14.3, \"labels\": {\"place\": \"us\"}}");
}