Saravanan666/pypi-org huggingface dataset:
Package: uqo
#UQO - You, Quantum and OptimizationUQO is an optimization framework developed by theQAR-Lab of the LMU Munich.SetupTo install UQO simply do:pip install uqoTo be able to connect to the UQO servers, you have to create a config object. There are two possibilities to do so:Generate private/public keysUQO uses elliptic curve cryptography to securely communicate with the UQO servers. Therefore you have to generate your
private and public key first, before you can start using UQO. This is done as follows:import os
  from uqo.generate_certificates import generate_certificates
  generate_certificates(os.path.dirname(os.path.realpath(__file__)))This will generate 3 folders ("certificates", "private_keys" and "public_keys") in your current working directory.
The "certificates" folder is used as a temporary directory and should be empty after the process completed. You can
safely delete this folder.Create the config object directly in the code:ip = "SERVER_IP:SERVER_PORT"
token = "YOUR_TOKEN"
private_key_file = "PATH_TO_YOUR_PRIVATE_KEY_FILE"
config = Config(method="token", credentials=token, endpoint=ip, private_key_file=private_key_file)Replace "PATH_TO_YOUR_PRIVATE_KEY_FILE" with the actual path to the clien.key_secret file you generated in step 1.Use a config fileCreate a config.json with the following structure:{
     "method": "token",
     "endpoint": "SERVER_IP:SERVER_PORT",
     "credentials": "YOUR_TOKEN",
     "private_key_file": "PATH_TO_YOUR_PRIVATE_KEY_FILE"
}

Replace "PATH_TO_YOUR_PRIVATE_KEY_FILE" with the actual path to the client.key_secret file you generated in step 1.You can then use this config file as follows:from uqo.client.config import Config
config = Config(configpath="Path\to\the\configfile")In the examples above please replace SERVER_IP and SERVER_PORT with the ip and port of the UQO server. Also replace YOUR_TOKEN with your personal UQO token.Current State of UQOAlthough UQO can already be used for a lot of tasks, it is still work in progress. You may very well run into problems where you
would like to use a feature which has not yet been implemented or is not working as intended due to bugs. In this case please let me know
about the exact problem or the exact feature you want to use, so I can fix / implement it.You find my E-mail at the bottom of this ReadMe.FAQRequired Python Version: >= 3.7Error messages while solvingIf you try to solve a problem with UQO you might run into problems. Please consider updating ALL your python packages that are relevant for UQO. After you have done this, verify that your code is correct. If you still encounter problems, you can contact me (sebastian.zielinski@ifi.lmu.de) and I will try to help you with your problem.
Package: uqpylab
UQ[py]LabUQ[py]Lab is the official python client of the UQCloud project, which aims at providing a cloud-based, language agnostic API to theUQLabuncertainty quantification framework.While still officially in a "beta testing" stage, UQ[py]Lab is close to its first public stable release, scheduled for Summer 2023.Before you startBecause of its cloud-based nature, UQ[py]Lab requires an authentication token, which can be freely obtained by registering for beta testing at the UQ[py]Lab website:https://uqpylab.uq-cloud.ioAfter registration, you will find all the information you need to connect to the UQCloud servers at your personal profile page onhttps://uqpylab.uq-cloud.io.InstallationTo install the package in your local Python environment, execute the following command:pipinstalluqpylabNotes:UQ[py]Lab requires Python version >= 3.9It is highly recommended to install UQ[py]Lab in a new Python virtual environmentFirst StepsTo get started with UQ[py]Lab, we strongly recommend new users to go peruse the following resources:The Getting started guide at:https://uqpylab.uq-cloud.io/getting-startedSome examples, related to their application of interest:https://uqpylab.uq-cloud.io/examplesLicenseUQ[py]Lab is free software, published under the open sourceBSD 3-clause license.
Package: uqtie
UQtieUtilities for QtA small set of features to make it easier to use PyQt5. Implements
a repetive pattern for quickly building throwaway or small
Qt applications. Features include Font Selection, Zoom In/Out,
and geometry persistence.Getting StartedPrerequisitesPyQt5is obviously required.Theuqtiedistribution package does not namePyQt5as a dependency
because you may have already installed it in some custom way, and
you don't want theuqtieinstallation process to create a redundantPyQt5installation.If you don't already have it, you can installPyQt5by doing this:pipinstallpyqt5Be aware that the appropriate installation procedure for a package can
vary depending on your OS and other factors.Installing uqtieInstall the package:pipinstalluqtieOr clone from GitHub:gitclonehttps://github.com/langrind/uqtie.gitand then run the setup script:pythonsetup.pyTo showuqtiein action, runsimple_uqtie.py. It's a do-nothing app,
the lets you select the font from the File menu, or zoom via the View menu.
It's copied in your $PATH when you install theUQtiepackage.TestsThere are no tests yet, beyond runningsimple_uqtie.py.DeploymentTBS: details about usage in different OS environmentsUsing UQtieModule NamePurposeUqtMavUqtMavConn allows easy use of pymavlink connections in Qt appUqtWinMainWindow class provides an app main window with featuresUqtStylesheetAllows app to maintain a QSS file with variable properties -a "poor man's SASS"You can view the source ofsimple_uqtie.pyin theexample/subdirectory of the repo.There are three items of note:Import theUqtWinmodule:from   uqtie import UqtWinDefine a subclass ofMainWindowclass TestAppMainWindow(UqtWin.MainWindow):
    def __init__(self, parsedArgs, **kwargs ):
        super(TestAppMainWindow, self).__init__(parsedArgs, **kwargs)Instantiate the subclass# can add optional title='<OptionalTitle>' if it is different from your app name
mainw = TestAppMainWindow(parsedArgs, app=app, organizationName='Craton', appName='UqtTest')For more info,RTFD.ContributingThis project isad hocin nature, so I don't foresee contributions. Nevertheless,
feel free to make a pull request.VersioningVersions are assigned in accordance withSemantic Versioning.
For the versions available, see thetags on this repository.Pronunciation"uqtie" is pronouncedYou Cutie:heart_eyes:"Uqt", used as a prefix in the code, rhymes with "duct"AuthorsNik Langrind-Sole authorLicenseThis project is licensed under the MIT License - see theLICENSEfile for detailsAcknowledgmentsI used thePurpleBoothREADME template
Package: uqtils
Assorted utilities for uncertainty quantification and scientific computing.InstallationYou can install normally with:pipinstalluqtilsIf you are usingpdmin your own project, then you can use:cd<your-pdm-project>
pdmadduqtilsYou can also quickly set up a development environment with:# After forking this project on Github...gitclonehttps://github.com/<your-username>/uqtils.gitcduqtils
pdminstall# reads pdm.lock and sets up an identical venvQuickstartimportnumpyasnpimportuqtilsasuqndim,nsamples=3,1000mu=np.random.rand(ndim)cov=np.eye(ndim)samples=uq.normal_sample(mu,cov,nsamples)fig,ax=uq.ndscatter(samples)ContributingSee thecontributionguidelines.Made with theUQ pdm template.
Package: ura-api
URA Token PackageThis is a python wrapper to URA APIs.Register for your access key withURAExample:fromura_apiimportura_apiura=ura_api.ura_api('<place valid access key here>')ura.car_pack_available_lots()Available APIs## Car Parkscar_pack_available_lots()car_pack_list_and_rates()season_car_pack_list_and_rates()## Private Propertiesprivate_residential_property_transactions()private_non_landed_residential_properties_median_rentals_by_name()# Data are available for download by reference quarter.# Period field is in format of yyqq e.g. 14q1 represents 2014 1st quarter.private_residential_properties_rental_contract(period)# Data are available for download by reference quarter.# Period field is in format of mmyy e.g. 0913 represents Sep 2013.private_residential_property_units_sold_by_developers(period)private_residential_projects_in_the_pipeline()## Planning Decisionsplanning_decisions(year,last_dnload_date)## Approved Useapproved_residential_use(blkHouseNo,street,storeyNo,unitNo)Questions or bugs, please write tochengguan.teo@gmail.com.
Package: uracoli-rsensor
uracoli-rsensor - A Framework for Logging Sensor ValuesAbstractThe uracoli-rsensor package provides a logging of data from a MQTT
broker into a database (sqlite or MySQL).SetupThe package can installed directly from the sources.pip install git+https://gitlab.com/uracoli-project/uracoli-rsensor.gitQuickstartTo quickly log sensor data from a MQTT broker in a SQLite database write a minimal config fileminial.cfg:database:
  dbtype: sqlite
  dbname:  /tmp/rsensor-database.sqlitedb
mqtt:
-  host: test.mosquitto.org
   port: 1883
   prefix: rsensor-testNote: The "dash" before the "host:" keyword means there can be a list of MQTT brokers.Run the test data generator in the background or in a seperate shell:rs_testgen -H test.mosquitto.orgSee your data arrive at the broker (optional step):mosquitto_sub -h test.mosquitto.org -t "rsensor-test/#" -vRun the data logger script:mqtt_to_db -C minimal.cfgTo see whats in the database, run:sqlite3 /tmp/rsensor.sqlitedb "select * from timeseries"... or human readable:sqlite3 /tmp/rsensor.sqlitedb  "SELECT strftime('%Y-%m-%d %H:%M:%S', datetime(t.ts, 'unixepoch')) as string, s.id, t.value FROM timeseries AS t JOIN sensors AS s ON s.sensor_idx = t.sensor_idx"Documentationhttps://uracoli-rsensor.readthedocs.io/en/latest/LicenseThe contents of uracoli-rsensor is licensed with a Modified BSD License, see
file LICENSE for further details.
Package: uraeus.nmbd.python
URAEUS| NMBD-PyNumerical Multi-Body Dynamics in Python| A numerical simulation environment of constrained multi-body systems.Descriptionuraeus.nmbd.pythonis a numerical simulation environment developed in python, that generates numerical object-oriented code from symbolic models developed inuraeus.smbd, and provides various numerical solvers for multi-body systems.Please visituraeus.smbdfor more information aboutaudience,fields of applicationsandbackground.FeaturesToDoInstallationToDoUsage Examples & TutorialsToDoDetailed Example - Spatial Fourbar MechanismToDoRoadmapTo be discussed ...Implementation DetailsTheImplementation Detailswill be provided in a separate documentation and linked hereTheoretical BasisTheTheoretical Basiswill be provided in a separate documentation and linked hereSupportAs the tool is developed and maintained by one developer for now, if you have any inquiries, do not hesitate to contact me atkhaled.ghobashy@live.comorkh.ghobashy@gmail.comReferencesToDoLicenseToDo
Package: uraiko
Let’s say you are working with urls in your application and you need to
check whether the url is okay and if it redirects to another
destination. Of course, we have some awesome libraries already to get
this done. Buturaikomakes it easy, you just feed the url and
voila! ### Installation You can install uraiko using pip,pipinstalluraikoRequires Python 3 or above to run. If you have Python 2 installed too,
make sure to use the right pip.Usage>>> import uraiko
>>> link = uraiko.url_check("iamlizu.com")
>>> print(link)
https://iamlizu.com/Please look for logs at ‘~/Documents/uraiko.log’What’s new in version 1.0.3Minor bug fixes
Package: ur-analytic-ik
UR Analytic IKC++ implementation with Python bindings of analytic forward and inverse kinematics for the Universal Robots based onAlternative Inverse Kinematic Solution of the UR5 Robotic Arm.This project is still very experimental, the API will likely still change.InstallationDon't forget to activate your venv or conda environment.Clone this repository, thencdur-analytic-ik
pipinstall.UsageAfterwards, you should be able to issue the FK and IK functions like this:importnumpyasnpfromur_analytic_ikimportur5eeef_pose=np.identity(4)X=np.array([-1.0,0.0,0.0])Y=np.array([0.0,1.0,0.0])Z=np.array([0.0,0.0,-1.0])top_down_orientation=np.column_stack([X,Y,Z])translation=np.array([-0.2,-0.2,0.2])eef_pose[:3,:3]=top_down_orientationeef_pose[:3,3]=translationsolutions=ur5e.inverse_kinematics(eef_pose)More examples:importnumpyasnpfromur_analytic_ikimportur3ejoints=np.zeros(6)eef_pose=np.identity(4)eef_pose[2,3]=0.4tcp_transform=np.identity(4)tcp_transform[2,3]=0.1ur3e.forward_kinematics(0,0,0,0,0,0)ur3e.forward_kinematics(*joints)tcp_pose=ur3e.forward_kinematics_with_tcp(*joints,tcp_transform)joint_solutions=ur3e.inverse_kinematics(eef_pose)joint_solutions=ur3e.inverse_kinematics_closest(eef_pose,*joints)joint_solutions=ur3e.inverse_kinematics_with_tcp(eef_pose,tcp_transform)TestingIn the root directory of this repo, to run the tests:pytest -vDevelopmentSome linux users have eigen installed at /usr/include/eigen3 instead of /usr/include/Eigen. Symlink it:sudo ln -sf /usr/include/eigen3/Eigen /usr/include/Eigen
sudo ln -sf /usr/include/eigen3/unsupported /usr/include/unsupportedWelcome ImprovementsPython APIAdding an IK function that returns the closest solution and accepts a TCP transform.Reducing the amount of separate IK functions, e.g. replacing:ur3e.inverse_kinematics_with_tcp(eef_pose)# withur3e.inverse_kinematics(eef_pose,tcp=tcp_transform)The same holds for functions ending with_closest().PerformanceCurrently IK runs at about 10 μs / EEF pose on my laptop.
However, before I implemented the filtering of the solutions, it was closer to 3 μs.
Part of this is because I adapted the bindings inur_analytic_ik_ext.cppto return vectors with the solutions.Code QualityAdding more technical documentation.ur_analytic_ik_ext.cppshould be made much more readable.Reducing some duplication e.g. when defining the IK/FK functions and bindings for the different robots.
Package: uranie-launcher
This package contains uranie-launcherThis package contains uranie-launcherContactDescriptionInstallationPython style conventionsContactClément STUTZ (clement.stutz@cea.fr)DescriptionThe packageuranie_launcheris a Python package for easily launch a study with URANIE.InstallationThis package can be installed using pip.
For example the following line installs the package in developer mode (modifiable sources):pipinstall--user-e.Python style conventionsThis project use the code linterPylintfor coding conventions
andNumPy Style Python Docstringsfor docstrings formating.
Package: uranium
Uranium: an assembly tool for python, in python.uranium is an assembly tool that facilitates reuse and allows
for execution of arbitrary setup code for Python services. Examples
include:downloading and installing eggs in a sandbox (using virtualenv internally)downloading remote configurationproviding a framework for assembly configuration (e.g. differences
between dev and test mode)any other arbitrary tasksYou can find out more here:http://uranium.readthedocs.org/en/latest/Getting startedhttp://uranium.readthedocs.org/en/latest/tutorial.html
Package: uranium-image-cleanup
Uranium Image CleanupThis package was developed to process grayscale uranium images in a specified directory to remove text/labels.You should already have installed Python 2.7 - 4.0 with PIP. Python will need to be added as an environment variable.On Window's start Command Prompt or PowerShell. On Linux open up a terminal.To install:>>> pip install uranium-image-cleanupRun on Windows:Type "uic".>>> uic
    >>>
    >>> *** Uranium Image Cleanup  ***
    >>> Enter Image/s Retrieval Directory:How to find the uic.exe on Windows:In case you wanted to move it to the desktop for easy access.>>> where uic
    #Output: C:\Users\your_username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.       9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\Scripts\uic.exe
    >>>Alternative way of running:On Window's start Command Prompt or PowerShell. On Linux open up a terminal.Run python.>>> pythonImport the package then call main.>>> import uic_package as uic
    >>> 
    >>> uic.main()
    >>>
    >>> *** Uranium Image Cleanup  ***
    >>> Enter Image/s Retrieval Directory:This package is also capable of:Removing text/noise on a single image of uranium.Detecting white pixels on a single image.Below are examples on how to implement these.Remove labels on a single image:>>> import uranium_image_cleanup_package as uic
    >>> import opencv as cv2
    >>>
    >>> image uranium_nucleus_10593520                  
    >>> result_image = uic.removeLabel(uranium_nucleus_10593520)Detect white pixels on a single image:>>> import uranium_image_cleanup_package as uic
    >>> import opencv as cv2
    >>>
    >>> image uranium_nucleus_10593520                  
    >>> white_pixel_image = uic.detectWhite(img)For more info and access to all the methods available, consult the removeLabel.py script found in the uic_package folder.
Package: uranium-plus
uranium-plus: opinionated usage of uraniumuranium-plus is an alpha project. use at your own risk, and things are subject to changeuranium-plus is an opinionated way of using uranium,
relying on standardization to provide functionality out of the box:auranium testdirective, using pytestauranium publishdirective, to publish packagesauranium maindirective,standard conventionsyour tests live in either in a "tests" directory under your main module.a setup.py file is used to declare your packagethe main task can be overriden with any setup required to publish the application.using uranium-plus in your ubuild.pyYou can install uranium-plus, then call the provided boostrap function to bootstrap your repo. from that point on,
you will have all the standard uranium-plus goodies:# ubuild.py
build.packages.install("uranium-plus")
import uranium_plus

build.config.update({
    "uranium-plus": {
        "module": "my-module"
    }
})

uranium_plus.bootstrap(build)Using uranium-plus for vscodeuranium-plus includes built in configuration for
maximum compatibility with vscode's vscode-python extension.modify your uranium-plus installation to include the vscode extras:# ubuild.py
build.packages.install("uranium-plus[vscode]")
import uranium_plusDesign / Best Practicesuranium-plus ensures best practices that are not necessarily enforced by uranium
itself, this inclues:Installing all dependencies and requirements during the main() call.Developers may go offline at inopportune times. As a result, there should not
be surprise dependencies that are discovered only when the task is invoked for the
first time.uranium-plus moves almost all dependencies to the setup.py, and moves dependencies
that can only be resolved by user configuration (such as test.packages) to the main()
function to be installed then.
Package: uranium-quantum
This package contains support Python libraries for the Uranium quantum computing platform.the circuit_composer module allows creating circuits programatically in the yaml format used by Uranium.the circuit_exporter module is used to export circuits from the yaml format internally used by Uranium to external quantum circuit formats like Qiskit, OpenQASM, Cirq, Quil and PyQuil.For further details please visit:https://uranium.transilvania-quantum.org
Package: uranography
uranographyDescriptionDocumentation available athttps://uranography.lsst.iouranographyis a collection of tools for making plots on the celestial sphere withbokeh.
It is primarily intended for  use in interactive environments such as jupyter notebooks or dashboards.It supports a handful of map projections, and interactive tools that adjust them in ways that simulate traditional tools
used in astronomy:
the Lambert azimutal equal area projection simulates aplanisphere,
and the othrogrophic projection simulates anarmillary sphere.Theuranographymodule includes tools to produce:bokehtransformsthat apply the map projection in the client.projections ofhealpixandhealsparsearrays.graticules in equatorial coordinates (R.A. and declination),graticules in horizon coordinates (altitude and azimuth),the ecliptic plane,the horizon (or circles of any other altitude),circles of a sphere (great or small circes) with arbitrary centers and radii, or arcs of such circles beginning and ending at arbitrary bearings from the center.the galactic plane, andstars from theYale Bright Star Catalog.These methods addbokehglyphs, data sources, and renderer models with standard or manually assigned assigned names to an instance ofbokeh.plotting.Figure, so they can be selected by name and adjusted and refined using the standardbokehAPI.More documentation is available aturanography.lsst.io.
Package: ura-token-pkg-chengguan
URA Token PackageThis is a small example to obtain URA API token.Register for your access key withURAExample:importrequestsimportjsonfromura_tokenimportura_tokenu=ura_token.ura_token('<place your ura access key here>')url="https://www.ura.gov.sg/uraDataService/invokeUraDS?service=Car_Park_Availability"myobj={'AccessKey':u.get_accesskey(),'token':u.get_token(),'User-Agent':'Mozilla/5.0'}resp=requests.post(url,headers=myobj)print(json.dumps(resp.json()['Result'],indent=4))Questions or bugs, please write tochengguan.teo@gmail.com.
Package: uravo
python-uravoA python interface to the (still theoretical)Uravomonitoring system.Installation$ pip3 install uravoUsagefrom uravo import uravo
    import random

    def test_thing():
        return True if (random.randint(1,100) % 2) else False
        
    if test_thing():
        uravo.alert(Severity="green", AlertGroup="thing", Summary="Thing is good.")
    else:
        uravo.alert(Severity="red", AlertGroup="thing", Summary="Thing is bad.")This is mostly just a placeholder for early testing, at this point.  Since Uravo doesn't really exist, as such, this module will fail silently if it can't connect or if it's not installed.
Package: uravu
making Bayesian modelling easy(er)uravu(from the Tamil for relationship) is about the relationship between some data and a function that may be used to describe the data.The aim ofuravuis to make using theamazingBayesian inference libraries that are available in Python as easy asscipy.optimize.curve_fit.
Therefore enabling many more to make use of these exciting tools and powerful libraries.
Plus, we have some nice plotting functionalities available in theplottingmodule, capable of generating publication quality figures.In an effort to make theuravuAPI friendly to those new to Bayesian inference,uravuisopinionated, making assumptions about priors among other things.
However, we have endevoured to make it straightforward to ignore these opinions.In addition to the library and API, we also have somebasic tutorialsdiscussing how Bayesian inference methods can be used in the analysis of data.Bayesian inference in PythonThere are a couple of fantastic Bayesian inference libraries available in Python thaturavumakes use of:emcee: enables the use of theGoodman & Weare’s Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble samplerto evaluate the structure of the model parameter posterior distributions,dynesty: implements thenested samplingalgorithm for evidence estimation.ProblemsIf you discover any issues withuravuplease feel free to submit an issue to our issue tracker onGithub.
Alternatively, if you are feeling confident, fix the bug yourself and make a pull request to the main codebase (be sure to check out ourcontributing guidelinesfirst).Installationuravuis available from thePyPIrepository so can beinstalled usingpipor alternativelyclonethis repository and install the latest development build with the commands below.pip install -r requirements.txt
python setup.py build
python setup.py install
pytestContributors