Saravanan666/pypi-org huggingface dataset:
Package: unittestx
UnitTestXA custom unittest runner for Python's unittest framework.FeaturesCustom test result reporting.Colorful and informative test status output.Support for Python 3.8 and above.InstallationYou can install UnitTestX using pip:pipinstallunittestxUsageRun your tests using UnitTestX by simply invoking the unittestx command.
For example:unittestx-stests-p"test_*.py"You can pass the following arguments to the unittestx command:-sor--start-directory:Specifythedirectorytostarttestdiscovery(defaultis'.').
-por--pattern:Specifythetestfilepattern(defaultis'test*.py').
Formoreoptionsanddetails,usetheunittestx--helpcommand.ContributingContributions are always welcome!
Feel free to open issues, submit pull requests, or provide feedback.LicenseMIT
Package: unittest-xml
This library is a set of helper methods for testing XML with Python’s unittest library.
The new assertion methods useXPathto select the XML elements that assertions are being
made about.Sample usageTo use these additional assertions, simply mix thexmltest.XMLAssertionsclass
into your test class:import unittest
from xmltest import XMLAssertions

class MyTestCase(unittest.TestCase, XMLAssertions):
    passNow suppose you have the following XML string that you wish to examine:response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
<Response>
    <CardTxn>
        <authcode>060642</authcode>
        <card_scheme>Switch</card_scheme>
        <issuer country="UK">HSBC</issuer>
    </CardTxn>
    <reference>3000000088888888</reference>
    <merchantreference>1000001</merchantreference>
    <mode>LIVE</mode>
    <reason>ACCEPTED</reason>
    <status>1</status>
    <time>1071567305</time>
</Response>"""Assert the number of elements matching an XPath query:self.assertXPathNodeCount(response_xml, 1, 'CardTxn/issuer[@country="UK"]')
self.assertXPathNodeCount(response_xml, 1, 'status')Assert the value of a particular element:self.assertXPathNodeText(response_xml, 'ACCEPTED', 'reason')Assert the attribute values of an element:self.assertXPathNodeAttributes(xml, {'country': 'UK'}, 'CardTxn/issuer'}InstallationFrom PyPi:pip install unittest-xmlContributingTo run the tests, installnoseandmock:pip install nose mockand use:nosetests
Package: unitts
unittsa integrated tts api for difference platform and difference tts driverDependentstext2sentencesInstallationpip install unittsUsageimport unitts

tts = unitts.init(driverName)
tts.say(text, pos=0)if the tts driver need a setup parameters like appkey,
you should do it before unitts.init() is calledsupported driversmacosx_ttsbaidu_ttsandroid_ttsios_ttsSome of the drivers need setup it owns parameters before
unitts.init() called, please refer to the drivers documents for detail
Package: unitunes
unitunesA python GUI and library to sync playlists across music streaming services.Introductionunitunes manages playlists across streaming services. unitunes can transfer songs between services and keep playlists in sync.unitunes stores your playlists in plain text, allowing you to version control your music. Playlists can be pushed and pulled from streaming services. Tracks from one service can be searched on another.Current Supported Streaming ServicesNamePullablePushableSearchableMusicBrainz✅Spotify✅✅✅Youtube Music✅✅✅Beatsaber✅✅✅Want to add support for another service? Seecontributing.Usagepipinstallunitunes
unitunesIn settings, set the directory to store your playlists. You can version control this directory with git.Connect services in the service tab. Enter a service name, and click the button to add the corresponding service. Each service type requires some configuration, Spotify requires a client id and secret, and Youtube Music requires request headers.Playlists can then be added to the playlist tab.After adding playlists, you can sync them. You likely just want to press theSync Allbutton, which will pull, search, and push all playlists.Contributingunitunes is rapidly evolving. Take a look at thecontributing guide.
Package: unitxt
In the dynamic landscape of generative NLP, traditional text processing pipelines limit research flexibility and reproducibility, as they are tailored to specific dataset, task, and model combinations. The escalating complexity, involving system prompts, model-specific formats, instructions, and more, calls for a shift to a structured, modular, and customizable solution.Addressing this need, we present Unitxt, an innovative library for customizable textual data preparation and evaluation tailored to generative language models. Unitxt natively integrates with common libraries like HuggingFace and LM-eval-harness and deconstructs processing flows into modular components, enabling easy customization and sharing between practitioners. These components encompass model-specific formats, task prompts, and many other comprehensive dataset processing definitions. The Unitxt-Catalog centralizes these components, fostering collaboration and exploration in modern textual data workflows. Beyond being a tool, Unitxt is a community-driven platform, empowering users to build, share, and advance their pipelines collaboratively.https://github.com/IBM/unitxt/assets/23455264/baef9131-39d4-4164-90b2-05da52919fdf🦄 Currently on Unitxt Catalog🦄 Run Unitxt Exploration DashboardTo launch unitxt graphical user interface run:unitxt-explore🦄 ContributorsPlease install Unitxt from source by:git clone git@github.com:IBM/unitxt.git
cd unitxt
pip install -e ".[dev]"
pre-commit install🦄 CitationIf you use Unitxt in your research, please cite our paper:@misc{unitxt,
      title={Unitxt: Flexible, Shareable and Reusable Data Preparation and Evaluation for Generative AI},
      author={Elron Bandel and Yotam Perlitz and Elad Venezian and Roni Friedman-Melamed and Ofir Arviv and Matan Orbach and Shachar Don-Yehyia and Dafna Sheinwald and Ariel Gera and Leshem Choshen and Michal Shmueli-Scheuer and Yoav Katz},
      year={2024},
      eprint={2401.14019},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
Package: unityapiclient
A Python client library for the Unity IDM APIs.Currently, it only supprorts a subset of the operations exposed by Unity’s Administration API.Python versionPython 2.6 or 2.7 are fully supported.InstallationTo install the client library, simply run:$pipinstallunityapiclient🍺Third party libraries and dependenciesThe following libraries will be installed when you install the client library:pytzrequestsUsageThe following example assumes a Unity IDM deployment athttps://unity.example.org:>>>importunityapiclient>>>fromunityapiclient.clientimportUnityApiClient>>>client=UnityApiClient('https://unity.example.org',...auth=('unityapiuser','secretpassword'))>>>entity=client.get_entity(257)>>>entity['entityInformation']['state']u'valid'DocumentationDocumentation is available athttp://eudat-b2access.github.io/unity-api-python-clientLicenseLicensed under the Apache 2.0 license, for details seeLICENSE.
Package: unity_avindicator
Web/Microphone muting application-------------------This application was created as I was annoyed that there was not a Unity appthat I could use to quickly check my webcam and microphone status.It assumes a couple things:* Gtk2 and its python bindings are installed and available.* the requirements.txt file is installed* this uses the amixer command so if its not available for your system, too bad.* It assumes that you have a uvcvideo USB webcam.Before this will work you will need to add the following line to your sudoers file:Example:raptorx  ALL=NOPASSWD: /sbin/modprobe uvcvideoIf you want this to load on login add an entry in Ubuntu's StartupApplications.If you have an application that is currently using the webcam it will notwork until the application is closed.This was originally created and tested on and for a Gazelle System76 laptop.The included tests will determine if the toggling of the webcam and microphone work.Once installed to run the application manually type: avindicator
Package: unity-cv-datasetvisualizer
Unity Computer Vision Dataset VisualizerThis Python based tool allows you to visualize datasets created using Unity Computer Vision tools.RequirementsWindows 10 or OSXChrome, Firefox, or Safari 14 and newer (Older versions of Safari are not supported)Python 3.7 or 3.8. Note that this application is not compatible with Python 3.9.Running the visualizerRun the command:datasetvisualizerOr if you want to specify a path to a dataset:datasetvisualizer--data="<path_to_dataset>"This command may take a few seconds to execute. Once it is done, your browser will automatically open tohttp://localhost:8501/and display the application. If that does not happen, open a new browser tab and manually navigate to that address.Once in the application, you will be prompted to select a dataset folder. ClickChange Datasetat the left side of the screen and then select the root folder of your Unity Computer Vision dataset.Known issuesThe tool cannot open a dataset that has no labeler data (bounding boxes, semantic segmentation, etc.)On Windows: a warning appears when launching the app (This can be ignored)3D bounding boxes are not rendered properly when the camera is inside the box.Opening a folder that isn't a dataset folder may hang the program (The workaround is: kill the process and start it again)
Package: unitypackage-extractor
Unity Package ExtractorExtract your .unitypackageUsage without PythonDownload theunitypackage_extractor.zipfrom the Releases tab.Extract into a new directoryDrag and drop your.unitypackageontoextractor.exeORRun from the command line withextractor.exe [path/to/your/package.unitypackage] (optional/output/path)Usage with Python 3.6+pip install unitypackage_extractorFrom the command linepython -m unitypackage_extractor [path/to/your/package.unitypackage] (optional/output/path)OR in your Python file:fromunitypackage_extractor.extractorimportextractPackageextractPackage("path/to/your/package.unitypackage",outputPath="optional/output/path")For EnterpriseThe maintainers of thousands of packages (including me! :3) are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.Learn more.ContributingSeeCONTRIBUTING.md
Package: unity-project-version
Unity Project Version Management Command-line Interface (CLI)Command-line interface utility for manipulating the project version of a Unity project.% unityprjver --help

usage: unityprjver [-h] [--build-number NUMBER] [--logging-level LEVEL] --path PATH [--replace-patch-version]
                   [--update-version]

Unreal Engine project version utility

options:
  -h, --help            show this help message and exit
  --build-number NUMBER
                        specify the build number of the Unreal Engine project
  --logging-level LEVEL
                        specify the logging level (critical, error, warning, info, debug)
  --path PATH           specify the path to the Unreal Engine project
  --replace-patch-version
                        indicate whether to replace the patch version of the Unreal Engine project with the specified
                        build number. This argument MUST be used with the argument `--build-number`.
  --update-version      indicate whether to update the defined in the Unreal Engine project. This argument MUST be
                        used with the argument `--build-number`.
Package: unity-raw-to-exr
Unity RAW To EXRThis is a utility to convert the 16-bit raw heightmap data that Unity's Terrain System exports into a 16-bit EXR format.InstallationRun the following to install:pipinstallunity-raw-to-exrUsagefromunity_raw_to_exrimportraw_to_exrraw_to_exr("./tests/terrain-33.raw")Developing unity_raw_to_exrTo install unity_raw_to_exr, along with the tools that you need to develop and run tests, run the following in your virtualenc (venv):pipinstall-e.[dev]OtherSource DistributionTo create a source distribution:pythonsetup.pysdistUpdate the MANIFEST.inIf working on the development, the venv should already havecheck-manifestRefer tohttps://pypi.org/project/check-manifest/AcknowledgementsMark Smithhttps://github.com/judy2k/publishing_python_packages_talk
Package: unityrde
unityrdeunityrde (Unity raw data export) is a Python 3 package for pulling raw data from the Unity Analytics REST API. See theUnity documentationfor more information on how this works.Installationpython-mpipinstallunityrdeQuickstart guideFirstly, create a UnityDataImporter object and include your Unity project id and your API key:fromunityrdeimport*upid="aa43ae0a-a7a7-4016-ae96-e253bb126aa8"key="166291ff148b2878375a8e54aebb1549"udi=UnityDataImporter(upid,key)To pull data from the API you need to first either create a new data export, or use a data export that has been created previously. For the latter case, you need to get the export_id. The list_data_exports method can be used to identify previously created data exports:# Get a json of the metadata of all data exportsexports=udi.list_data_exports()# get the id of the most recent exportexport_id=exports[0]['id']You can then use the get_data_export method to get a json of the data from this export:data=udi.get_data_export(export_id)If you need to create a new export, you can run create_export. Make sure when setting the parameters that you include a startDate, endDate and dataset. For help on parameters, see theUnity documentation.params={'startDate':'2019-09-01','endDate':'2019-09-30','dataset':'appStart'}udi.create_export(params)This will create a new export_id, which is associated with the class through the export_id attribute. The export will usually take a minute or two to be created. You can check its status by looking at the export metadata:print(udi.get_data_export(output='metadata')['status'])Note that it was not necessary to specify the export_id this time. Once the status is completed, you can get a json of the data:data=udi.get_data_export()Alternatively, you can do all this in one step using the create_and_get_export method:data=udi.create_and_get_export(params)pandas and longer exportsFor convenience, there are a couple of methods in the package that allow you to output pandas dataframes. Firstly, any json data file you produce from the previous step can be converted using the convert_to_pandas functiondf=convert_to_pandas(data)Secondly, the make_long_df method can be used to export more than 31 days of data at once. It does this by creating multiple exports and appending them together into a single pandas DataFrame.params['startDate']='2019-08-01'params['endDate']='2019-10-14'df=udi.make_long_df(params)MaintenanceI made this package in a professional context. I am no longer able to test the functionality of the package, because I do not have access to a Unity Analytics account. I will fix obvious errors where I can, but if the Unity API changes in such a way that breaks this package, I will not be able to repair it.
Package: unity-sds-client
Unity-PyA Python client to simplify interactions with NASA's Unity Platform.[INSERT SCREENSHOT OF YOUR SOFTWARE, IF APPLICABLE]Unity-Py provides a seamless way to interact with NASA's Unity Platform using Python. Built to simplify the connection and data retrieval process, this client offers a programmatic interface to Unity's services.FeaturesPythonic interface to NASA's Unity PlatformSupport for interactive and environment variable-based authorizationContentsQuick StartChangelogFAQContributing GuideLicenseSupportQuick StartRequirementsPythonpipSetup InstructionsInstall via pypi:pip install unity-sds-clientInstall from Github:python -m pip install git+https://github.com/unity-sds/unity-py.gitBuilding and installing locally using poetry:git clone https://github.com/unity-sds/unity-py.git
cd unity-py
poetry installRun InstructionsAuthorization can be handled interactively, in which case you will be prompted for a username/password when calling the Unity() method, or can be handled by way of environment variables:export UNITY_USER=MY_UNITY_USERNAME
export UNITY_PASSWORD=MY_UNITY_PASSWORDOrder of Authentication Parameters:Environment variablesPrompt for username and passwordUsage Examplesfrom unity_sds_client.unity import Unity
from unity_sds_client.unity_session import UnitySession
from unity_sds_client.unity_services import UnityServices as services

s = Unity()
# set the venue for interacting with venue specific services
# if your venue id is a single string, use the following
s.set_venue_id("unity-sips-test")

# otherwise set the project and venue:
# s.set_project("sbg")
# s.set_venue("dev")

dataManager = s.client(services.DATA_SERVICE)
collections = dataManager.get_collections()
print(collections)

cd = dataManager.get_collection_data(collections[0])
for dataset in cd:
    print(f'dataset name: {dataset.id}' )
    for f in dataset.datafiles:
        print("	" + f.location)Test InstructionsRun all tests and include printouts:poetry run pytest -sRun non-regression tests:poetry run pytest -m "not regression"Run regression tests (and include logs)(Not Available Yet)ChangelogSee ourCHANGELOG.mdfor a history of our changes.See ourreleases pagefor our key versioned releases.Frequently Asked Questions (FAQ)No questions yet. Propose a question to be added here by reaching out to our contributors! See support section below.ContributingInterested in contributing to our project? Please see our:CONTRIBUTING.mdLicenseSee our:LICENSESupportPlease reach out to@anilnatha,@mike-gangl
Package: unity-test-parser
Unity Test ParserA Python 3 module for parsing the console output of theUnity Test Framework. Unity (not to
be confused with the far more popular graphics framework) is a unit testing
framework optimized for embedded C. This module is intended to solve a couple
of problems related to using Unity and to unit testing embedded apps in
general:Unity does not have a built-in method for generating XML or HTML output which
can be parsed by CI systems.Unity tests are often run in a simulator or directly on target hardware,
where the exit code of the test process cannot be captured. In these cases,
parsing the output is often the only possible method for determining whether
the tests passed or failed.This module can parse the output of basic Unity tests, of the form:path/to/file.c:100:test_name:PASS
path/to/file.c:101:other_test_name:FAIL: Expected 1 Was 2It can also parse the output of the Unity Fixture add-on, which groups tests
into test groups or "fixtures":TEST(group, test_name)path/to/file.c:100::FAIL: Expected 1 Was 2Installationunity-test-parser can be installed withpip:pip install unity-test-parserUsageGetting StartedUse theUnityTestResultsobject to do the initial parsing of Unity test
output. Assuming your test output is in a file, you can do:importunity_test_parserwithopen("results_file.txt","r")asresults_file:# This will raise ValueError if the results are improperly formattedresults=unity_test_parser.TestResults(results_file.read())You can inspect the individual tests, each represented by a UnityTest object:fortestinresults.test_iter():print("Test:{}Result was:{}".format(test.name(),test.result()))To convert the tests to JUnit XML:importjunit_xmlwithopen("test_results.xml","w")asout_file:junit_xml.TestSuite.to_file(out_file,[results.to_junit()])Test Results FormatCurrently two types of Unity output are supported for parsing: The output of
Unity used on its own (UNITY_BASIC) and the output of the unity_fixture extra
invoked with the-vflag (UNITY_FIXTURE_VERBOSE). Use the second__init__argument to theTestResultsobject to specify which format is being parsed.UNITY_BASICis the default. If the results are in an invalid format,
ValueError is raised.results=unity_test_parser.TestResults(basic_results_file.read(),unity_test_parser.UNITY_BASIC)fixture_results=unity_test_parser.TestResults(fixture_results_file.read(),unity_test_parser.UNITY_FIXTURE_VERBOSE)
Package: unity-yaml-normalize
unity-yaml-normalizeNormalize and overwrite Unity YAML files(onfigurations, prefabs, scenes, serialized data, etc) entries.Implemented byunity-yaml-parser. thanks!Sort entries memberNormalize negative zero.Installpip install unity-yaml-normalizeUsageusage:unity-yaml-normalize[-h][-v][-oOUTPUT]INPUT

positionalarguments:INPUTinputfile

optionalarguments:-h,--helpshowthishelpmessageandexit-v,--versionshowprogram'sversionnumberandexit-oOUTPUT,--outputOUTPUToutputfilepathe.g.unity-yaml-normalize sample/SampleScene.unity -o tmp/SampleScene.unitysample/SampleScene.unity -o tmp/SampleScene.unity
Package: universa
UniversaThis is an under-construction official Python package fromUniversato facilitate access to the Java library using Universa's UMI protocol.InstallationInstallationpipinstalluniversaUsagePrerequisitesYou need to haveUMIinstalled somewhere on your system.
To run, UMI requires JVM v1.8.* (or newer) to be installed, too.UMI can be used in one of three modes:pipe– the UMI instance is dynamically executed in a subprocess, and a pipe is used for communication.tcp– connect to an already running UMI instance via TCP socket.unix– connect to an already running UMI instance via Unix socket.By default it expects anumibinary to be installed an reachable via the shell$PATH, and will invoke it automatically inpipemode.
Useuniversa.transport.setupUMImethod if you need to switch the connection method to some other.Example#!/usr/bin/env python3fromuniversa.transportimporttransportfromuniversa.typesimportPrivateKey,Contract,RevokePermissionif__name__=='__main__':# The next line is not necessary if umi is reachable via the $PATH# transport.setupUMI('pipe', '/usr/local/bin/umi')# To connect to an already running UMI instance you may use one of this modes:# transport.setupUMI('tcp', host='127.0.0.1', port=12345)  # IPv6 is also ok# transport.setupUMI('unix', path='/path-to-the-socket')print(transport.version)private_key=PrivateKey(size=2048)contract=Contract()short_address=private_key.public_key.short_addressowner_role=contract.set_owner_addresses(short_address)revoke_permission=RevokePermission(owner_role)contract.add_permission(revoke_permission)Docs and resourcesFor more information see:Universa Knowledge BaseUniversa Java APIUniversa UMI serverLicenseThis package is available as open source under the terms of theMIT License.
Package: universal-answer-package-tutorial
Universal AnswerUniversal tool to determine the answer. Only used to test Python packaging.InstallationRun the following to install:pip install universal-answer-package-tutorialUsagefromanswerimportdetermine_answer# Find the general answerdetermine_answer()# Or provide some parametersdetermine_answer()Developing Universal AnswerTo install answer, along with tools you need to develop and run tests, run the following in your virtualenv:pip install -e .[dev]