Saravanan666/pypi-org huggingface dataset:
Package: qtdatasetviewer
Qt Dataset ViewerThis module is for debugging ML projects. It is PyQt5 based viewer for torch.utils.dataset.InstallationUse the package managerpipto installqtdatasetviewerfrom PyPi.pipinstallqtdatasetviewerUsageimportsysfromglobimportglobfromdatasetimportSampleDatasetfromPyQt5.QtWidgetsimportQApplicationfromPILimportImagefromqtdatasetviewer.abstract_convert_to_pilimportAbstractConvertToPilfromqtdatasetviewer.qt_dataset_viewerimportrun_qt_dataset_viewerimporttorchvision.transformsasTclassConvert(AbstractConvertToPil):defconvert(self,item)->Image:image,mask=itemtransform=T.ToPILImage()returntransform(image)if__name__=="__main__":dataset=SampleDataset(files=glob("data/*.*"))run_qt_dataset_viewer(Convert(dataset))DisclaimerThe package and the code is provided "as-is" and there is NO WARRANTY of any kind.
Use it only if the content and output files make sense to you.
Package: qt-desktop-translate
qt-desktop-translateqt-desktop-translate allows translating .desktop files using .ts files from Qt.InstallationInstall qt-desktop-translate with pippip install qt-desktop-translateCreate translationsTo create translations, use desktop-lupdatedesktop-lupdate your_desktop_file.desktop your_ts_file.tsThis will add the fields from the .desktop file to the .ts file. Now you can use Qt Linguist or any other tool, that allows translating .ts files. Call desktop-lupdate everytime after you've ran the normal lupdate. You can specify a folder instead of a single .ts file.Apply translationsTo apply translations, use desktop-lreleasedesktop-lrelease your_desktop_file.desktop output.desktop your_ts_file.tsThis will translate desktop-lupdate your_desktop_file.desktop using the translations from your_ts_file.ts. The output will be written into output.desktop. You can specify a folder instead of a single .ts file.
Package: qt-dev-helper
Qt Dev HelperToolbox to help develop Qt applications, improving the usability of the existing tooling.Installationpip install qt-dev-helperORconda install -c conda-forge qt-dev-helperFeaturesUsable as Library and/or CLI toolCompatible withPEP517build system
(see test case)CLI auto completionProject wide configuration inpyproject.tomlRecursive asset compiler for Qt projects (usinguicandrcc):*.ui->*.py*.qrc->*.py*.ui->*.h*.qrc->*.h*.scss->*.qssSupport for multiple Qt tooling suppliersPySide6-Essentialsqt6-applicationsqt5-applicationsAbility to open all files in a folder in QtDesignerPlanned featuresStand alone executable for each release (Windows)File watch modeqssinjection into*.uifilespre-commithooksFAQQ: Why isPyQt5not supported?A:PyQt5only ships a python specific version ofuicandrccbreaking the tool API and
compatibility with cpp projects.
Use the matching version ofqt5-applicationsas Qt tooling supplier.Contributors ✨Thanks goes out to these wonderful people (emoji key):Sebastian Weigand💻🤔🚧📆🚇⚠️📖Joris Snellenburg👀This project follows theall-contributorsspecification. Contributions of any kind are welcome!
Package: qtdigest
qtdigestpython implementation of Dunning's T-Digest, inspired bynodejs tdigestInstallpipinstallqtdigestUsagefromqtdigestimportTdigestt=Tdigest()foriinxrange(1000):t.push(random())P90=t.percentile(0.9)print'P90 = ',P90APITdigest(delta=0.01, K=25, CX=1.1)delta: the compression factor, the max fraction of mass that can be owned by one centroid (bigger, up to 1.0, means more compression).K: a size threshold that triggers recompression as the TDigest grows during inputCX: specifies how often to update cached cumulative totals used for quantile estimation during ingest.return: Tdigest instanceInstance of Tdigestpush(x, n): add data with value x and weight nsize(): return the count of centroidstoList(): return the list of all centroids datapercentile(p): return the percentage of p(0..1)serialize(): serialize tdigest instance to string, ie:0.01~25~2~0.00064~0.0013~2~20simpleSerialize(): simply serialize tdigest instance to string, ie:0.00064~2~0.0013~20deserialize(serialized_str): deserialize the serialized string to tdigest instance. it is a classmethod, so can be called byTdigest.deserialize(serialized_str)Performanceplatform： MacBook Pro (2.6 GHz Intel Core i5)data size (push times)cost time1K0.07s10K0.2s100K1.7s1M17s
Package: qtdraw
QtDraw3D drawing tool for molecules and crystals based onPyVistaandQt.
Drawings are associated with crystallographic symmetry operations provided byMultiPie.Authors: Hiroaki KusunoseCiting QtDraw and MultiPie: If you are using QtDraw and/or MultiPie in your scientific research, please help our scientific visibility by citing our work:Hiroaki Kusunose, Rikuto Oiwa, and Satoru Hayami, Symmetry-adapted modeling for molecules and crystals, Phys. Rev. B107, 195118 (2023).DOI:https://doi.org/10.1103/PhysRevB.107.195118Installation: QtDraw can be installed from PyPI using pip on Python >= 3.9:pip install qtdrawIt is useful to associate with the following application with.qtdwand.cifextension.MacWindowsYou can also visitPyPIorGitHubto download the source.See also,Install Guide (in Japanese)Shell commandqtdraw [filename]is available.Requirements:This library requiresTeXLiveenvironment.Symmetry operation supports are provided byMultiPie.See also:Manual (QtDraw and MultiPie).MyST syntax cheat sheetMultiPie tutorial (in Japanese)QtDraw tutorial (in Japanese)
Package: qtealeaves
qtealeavesThe qtealeaves library of Quantum TEA contains tensor network representation as
python classes, e.g., MPS, TTN, LPTN, and TTO. qtealeaves is the API for building
quantum models in Quantum TEA and has for example a single-tensor update ground state
search for TTNs. Moreover, qtealeaves is backbone for running quantum circuits via
Quantum matcha TEA and the frontend for the fortran backend running Quantum Green TEA,
i.e., solving the Schrödinger equation.DocumentationHereis the documentation. The documentation can also be built locally via sphinx.LicenseThe projectqtealeavesis hosted at the repositoryhttps://baltig.infn.it/quantum_tea_leaves/py_api_quantum_tea_leaves.git,
and is licensed under the following license:Apache License 2.0The license applies to the files of this project as indicated
in the header of each file, but not its dependencies.InstallationIndependent of the use-case, you have to install the dependencies. Then,
there are the options using it as a stand-alone package, withinquantum
matcha TEA, or for quantum green TEA.Local installation via pipThe package is available via PyPi andpip install qtealeaves.
After cloning the repository, an local installation via pip is
also possible viapip install ..DependenciesThe python dependencies can be found in therequirements.txtand are required independently of the following use-cases.Stand-alone packageIf you are looking to explore small exact diagonalization examples,
want to run a single-tensor update ground state search with TTNs,
or have TN-states on files to be post-processed, you are ready to
go.qmatchatea simulationsQuantum circuit simulations via qmatchatea have qtealeaves as a
dependency. Follow the instructions to install qmatchatea to get
the right version of qtealeaves.qgreentea simulationsIf you want to use the qgreentea toolchain with TTNs and aTTNS, you need to
install qtealeaves under a matching version. qgreentea provides instructions
which version is compatible; see installation instructions there. qgreentea
is not yet public, but it will be made public step-by-step.
Package: qtemplate
qtemplateA command line tool for managing and generating files or scripts from templatesOverviewqtemplateis a linux command line tool that helps generate files from templates, settings/datafiles, and command line prompts. A common task is creating new scripts or files that follow a convention you want to adhere to. You want access to create these base scripts but don't want to have to copy files and manually replace tags.qtempalte is meant to have the feel of shell aliases, where defining a new template is easy and instantiating a new template is easy. By creating a simple directory structure for storing templates, default data, and plugins, we can ensure templates are available at a your fingertips, without pausing.Structureqtemplate supports system level configurations under/etc/qtemplatethat are overwritten by user level configurations under~/.qtemplate/.qtemplate/
├── conf.yaml
└── templates
    └── example_template
        ├── example.jinja
        ├── example.json
        └── example.yamlUnder the conf.yaml, you can configure your template stores. Default template stores are localhost directories.template_storesThe template stores config is the ordering in which templates are looked up. This is a cascading list in the conf.yaml:template_stores:-https://www.qsonlabs.com/qtemplate/registry/templates/-file://user@remote-host/etc/qtemplate/templates-file://localhost/~/.qtemplate/templates/-file://localhost/etc/qtemplate/templatesEach store should be a valid URI andqtemplatewill handle pulling the data using the appropriate connector. If a given template is not found, it will check the next template store in the list. This enables remote template repositoriesTemplatesA template should have at most 3 files:*.jinja - Mandatory file for a template. There should only be one .jinja file and that will be the template usedtemplate.conf - a file used to specify any template level configurations. All of these configs can be overwritten with command line params*.data  - any default data that should be supplied to the jinja template. Default data can be provided directly in the jinja file but a separate .data file is more explicit. the *.data file can be json or yaml
Package: qterm
QTermQTerm is a Python module for spawning child applications and controlling them automatically.Installpip install qtermUsageTo interract with a child process useQTermclass:fromqtermimportQTermwithQTerm()asterm:print(term.exec('cd'))In case command prompt pattern changes usetemp_promptmethod:fromqtermimportQTerm,PYTHONprint(PYTHON)withQTerm()asterm:withterm.temp_prompt(*PYTHON):print(term.exec('1+1'))# TermArgs(SPAWN_COMMAND='python', PROMPT=re.compile('^>>> '), EXIT_COMMAND='exit()')# ['2']
Package: qtextras
Qt ExtrasGeneral Scientific Python Qt GUI UtilitiesA collection of Python Qt GUI builders and other functions I've found helpful as I develop
python mockups.Installationqtextraslives in pypi too, so the easiest way to install it is throughpip:pipinstallqtextrasNote that a version of Qt must be installed for it to work, such as PyQt5/6 or Pyside2/6.
PySide6 will also be installed withpip install qtextras[full]Alternatively, you can do so through downloading the repository:gitclonehttps://gitlab.com/s3a/qtextras
pipinstall-e./qtextras# Or ./qtextras[full] as mentioned aboveUsageUsage will vary depending on the requested capabilities. Check out theexamplesfolder for some usages
Package: qtfind
QtFindgraphical interface for the powerful command findInstallationDescriptionLicenseFeaturesReport a bugScreenshotsChangelogInstallationpip install qtfindTo avoid running the app from the command line, you need to add it to your apps menu:Download thisscriptOpen the terminal andcdto the location ofsetup.shrun:chmod u+x setup.shrun:./setup.shHead to your apps menu, type qtfind or you can find it under Accessories.Description:mag:QtFindis a graphical interface for the powerful commandfind.:mag:QtFindis designed with new comers to linux in mind.:mag:QtFindalso reveals the full command of the selected combination.:mag:QtFindis made with PyQt5from the man pageGNU find searches the directory tree rooted at each given file name by evaluating the given expression from left to right, according to the rules of precedence.LicenseThis program comes with absolutely no warranty.
See theGNU General Public Licence, version 3 or later for details.FeaturesDefault and dark (4 tones) themesShow/Copy constructed commandInterrupt searchMost of find options available (refer toman findfor more information)Report a bughttps://github.com/amad3v/QtFind/issuesScreenshotsDark theme (tone: green):Default theme:Changelog1.0.3:Added About QtMinor changes1.0.2:Fixed issue saving settings in different Linux distros (dbm related)1.0.1:Clean-up code1.0:Initial releaseCopyright :copyright: 2019 - amad3v
Package: qtforms
mikroqtforms is a library that allows you to create simple forms in Qt for Python with the help of
pydantic.InstallationpipinstallqtformsQuick StartfromqtpyimportQtWidgetsfrompydanticimportBaseModel,validator,Fieldimportsysfromqtforms.labeled_registryimportLabeledWidgetRegistryfromqtforms.formimportFormclassMyModel(BaseModel):name:str=Field("hundi",min_length=3,max_length=50,description="Your name")number:int=Field(1,ge=0,le=100,description="A number between 0 and 100")@validator("name")defname_must_contain_space(cls,v):if" "notinv:raiseValueError("Name must have a space")returnv.title()if__name__=="__main__":app=QtWidgets.QApplication(sys.argv)model=MyModel(name="hello world")##model.events.name.connect(lambda x: print(x))form=Form(LabeledWidgetRegistry(),MyModel,initial_data=dict(name="hello world"),auto_validate=True)form.submit.connect(lambdax:print(x))form.show()sys.exit(app.exec_())DesignFor the design of qtform, we use the following design:Formis the container and controller for the form. It calls the widget registry to spawn the widgets for the fields.
These widgets need to follow theFormWidgetinterface, and implement functions to set values and report errors.Formalso handles the validation of the form, and emits asubmitsignal when the form is valid and the submit button is pressed
(or when auto_submit is enabled on each valid change). Validation is done by pydantic, and the validated values are immediately
reported to the widgets.
Package: qtgallery
Scraper for generating asphinx-galleryof Qt widgets.This repository serves both as a library for grabbing renderings of Qt widgets
to add to your ownsphinx-galleryconfig as well as an example of its usage.InstallationFor the time being, clone the repo and install from source:$ git clone git@github.com:ixjlyons/qtgallery.git
$ cd qtgallery
$ pip install .Now you should be able to generate the docs/gallery:$ cd doc
$ make htmlOpen updoc/_build/html/index.htmlto see built docs. They’re currently
being hosted by Read the Docs as well:https://qtgallery.readthedocs.io/ConfigurationTo useqtgalleryin your own documentation, start by setting upsphinx-gallery. This library provides two key components to add to yoursphinx_gallery_conf: animage scraperand areset function:# sphinx conf.pyimportqtgallerysphinx_gallery_conf={...'image_scrapers':(qtgallery.qtscraper,...),'reset_modules':(qtgallery.reset_qapp,...),...}The image scraper is responsible for generating a rendering of all currently
shown top level widgets.The reset function is for handlingQApplication, allowing you to instantiate
theQApplicationsingleton in each example and preventing the Qt event loop
from running and hanging the docs build. That is, examples that run ok standalone
should behave ok in generating the gallery.UsageUsage pretty much followssphinx-gallery, but one tip is that you can controlwherethe widget/window is rendered viashow(). See theiterative
exampleto see how this works.Read the DocsOn Read the Docs,xvfbis required. See their documentation forinstalling
apt packages. This repository also serves as an example (see.readthedocs.yml).
Package: qt-graph-helpers
== Qt Graph Helpers ==Qt Graph Helpers are a group of PyQt helpers that could not be implemented in python as they would be too slow. They are used in Orange (https://github.com/orange3).= Prerequisites =Qt Graph Helpers need sip and development versions of Qt and PyQt to build. (qt-dev, python-qt-dev or similar on linux).= Installation =To install run:python setup.py install
Package: qtgrid
qtgridThis pythonqtgridpackage is forPyQt, orPySidedevelopers. It helps to buildQGridLayout'sdynamically and with visual help during implementation time. Note thatqtgridworks in the same way for PyQt6, PyQt5, and PySide6.Please visit thedocumentation homepageto find an example usage, atutorial, areference manual, and for the brave theAPI Documentation.InstallUse pip or pipenvpip install qtgridpipenv install qtgridGet the current development source from GitHubgit clonehttps://github.com/devlog42/qtgridWhen importingqtgrid, for an installation of PyQt6, PyQt5, or PySide6 is tested in that order.
If none of these are found, a corresponding error message is issued.ContributionEvery contribution that advances this project is very welcome.If you want to report a bug or ask about a new feature, please visit the dedicatedissuespage. There you'll find suitable templates for your request, including one that is esspecially intended for mistakes in the documentations.However, if you want to get involved in development, please check out theContributionpage first.When you write posts, it goes without saying that you use a friendly language. Of course there is also a separate page on the topic calledCode of Conduct.LicenseTheLicenseof this package comes in terms ofGNU LGPLv3.
Package: qtheory
It is a Python library implementing the Queueing theory calculations. As my term paper, I am developing a library, implementing the calculus of queuing theory. This library has the objective of characterising some queuing theory params as the queue arrival rate of clients, attendance rate and others… Implementing in python, this library receives a input file with queue data and gives the output answers. For the undergraduate thesis, I had toke some datas in a real queue and submited to the library as a input, to validate this project.
Package: qThread
qThread provides an simplified and safe way to stop long running
threads.  Typical uses often look like this:# Test / Usage of the stoppable thread
class MyThreadingClass(StoppableThread):
    def __init__(self, a):
        super(MyThreadingClass, self).__init__()
        self.a = a
        self.b = "World"
        self.delay = .5 # seconds

    def startup(self):
        # Overload the startup function
        print "My Thread Starting Up..."

    def cleanup(self):
        # Overload the cleanup function
        print "My Thread Is Shutting Down..."
        # Close files, ports, etc...
        time.sleep(4)
        print "Cleanup Complete!"

    def mainloop(self):
        # Some routine to be called over and over
        # ie: reading ports or sockets
        print self.a + " " + self.b

        # Throttling needs to be done here if the
        # primary function is not blocking
        time.sleep(self.delay)
Package: qtico
This package provides tools to manage PyQt icon themes.TheQIcon.fromThemeAPI works with icon themes following thefreedesktop icon theme spec,
which is great for Linux systems with installed and enabled themes, but not for Windows or OS X, which lack them.To benefit, you just have to create a theme directory with the right structure and use this package’s functions:icons (The default directory name)
├hicolor
│├16x16/apps/myapp.png
│├32x32/apps/myapp.png
│┆
│└scalable/apps/myapp.svg
└mypackage-builtin
 ├16x16
 │├actions
 ││├document-open.png
 ││┆
 │├mimetypes
 ││├application-x-mymime.png
 ┆┆┆This package provides the following functions to ease bundling an in-memory icon theme for those systems:write_theme_indicesCreates.index.themefiles from the.pngand.svgfiles.write_resourcesCreate a.qrcand_rc.pyfile to import the icon data from. (Needs the.index.themefiles)write_iconsetCreates a iconset folder for OSX apps, e.g. viapy2app, using thehicolor/
x
/apps/myapp.pngfiles.install_icon_themeTo be used in a running application to make the builtin icons available.Thehicolor/
x
/apps/myapp.pngfiles can beinstalled to the system by packagers (/usr/share/icons/hicolor/…)subsequently used in a .desktop file (Icon=myapp)used as window icon (self.setWindowIcon(QIcon.fromTheme('myapp')))
Package: qtics
Qtics - Quantum Technologies Instrumentation ControlSOverviewQtics is a collection of tools designed to facilitate the instrumentation of theBiQuTe Cryogenic Laboratory.In the experiments folder, some experiments are provided as examples, along with
various helpers.DocumentationYou can find the latest documentationhere.Installation instructionsStable version:To install the latest released version, you can use the standard pip command:pipinstallqticsLatest version:To install the latest version, unreleased, you can first clone the repository
with:gitclonehttps://github.com/biqute/qtics.gitthen to install it in normal mode:pipinstall.Use poetry to install the latest version in developer mode, remember to also
install the pre-commits!poetryinstall--withdocs,analysis,experiments
pre-commitinstallLicenseQtics is licensed under theApache License 2.0. See theLICENSEfile for details.
Package: qtido
qtidoest une bibliothèque Python(3) pour tracer des figures géométrique et faire des petits jeux.
Une sorte de documentation est disponible surhttps://learn.heeere.com/python/reference-qtido/Elle est basée sur les principes de conception et buts suivants :offrir une version de la biblothèque dans la langue de l'apprenant (le français ici, mais qtido est conçue pour être traduite),offrir une interface de programmation impérative sans "callback" ni asynchronisme apparent,permettre, entre autre, de faire des animations à interval de temp constant (si l'ordinateur est assez rapide),créer une abstraction qui permette un exécution des programmes aussi bien sur desktop (avec PyQt) que dans un navigateur (brython + implémentation en javascript de la bibliothèque)Le nom est un mélange deQt(composant graphiques utilisés par défaut) et deido(langue universelle).Installationpip install qtidoExemple simplefromqtidoimport*defmickey(fen,x,y,rayon):"""Cette fonction trace un mickey"""couleur(fen,1,1,1)# Blancdisque(fen,x,y,rayon)# cX, cY, rayoncouleur(fen,1,0,0)# Rougedisque(fen,x+rayon/2,y-rayon,rayon/2-1)disque(fen,x-rayon/2,y-rayon,rayon/2-1)couleur(fen,0,0.7,0)# Vertdisque(fen,x,y,rayon/5)f=creer(400,200)# créer une fenêtremickey(f,50,50,20)mickey(f,100,50,5)mickey(f,200,50,20)mickey(f,250,50,20)mickey(f,300,50,20)mickey(f,100,120,40)mickey(f,200,120,30)mickey(f,300,120,20)mickey(f,350,120,10)attendre_fermeture(f)