Saravanan666/pypi-org huggingface dataset:
Package: pyhandsontable
pyhandsontableView a list of JSON-serializable dictionaries or a 2-D array, in HandsOnTable, in Jupyter Notebook.Nested JSON renderer is also supported and is default. Image and markdown renderers are possible, but has to be extended.Installationpip install pyhandsontableUsageIn Jupyter Notebook,>>>frompyhandsontableimportPagedViewer>>>viewer=PagedViewer(data=data_matrix,**kwargs)>>>viewer'A Handsontable is shown in Jupyter Notebook.'>>>viewer.view(-1)'The last page is shown.'>>>viewer.previous()'The previous page (i-1) is shown.'>>>viewer.next()'The next page (i+1) is shown.'Data matrix can be either a list of lists (2-D array) or a list of dictionaries.It is also possible to view all entries at once, but it could be bad, if there are too many rows.>>>frompyhandsontableimportview_table>>>view_table(data_matrix,**kwargs)Acceptable kwargsheight: height of the window (default: 500)width: width of the window (default: 1000)title: title of the HTML filemaxColWidth: maximum column width. (Default: 200)renderers: the renderers to use in generating the columns (see below.)autodelete: whether the temporary HTML file should be autodeleted. (Default: True)filename: filename of the temporary HTML file (default: 'temp.handsontable.html')config: add additional config as defined inhttps://docs.handsontable.com/pro/5.0.0/tutorial-introduction.htmlThis will override the default config (per key basis) which are:{data:data,rowHeaders:true,colHeaders:true,columns:columns,manualColumnResize:true,manualRowResize:true,renderAllRows:true,modifyColWidth:(width,col)=>{if(width>maxColWidth)returnmaxColWidth;},afterRenderer:(td,row,column,prop,value,cellProperties)=>{td.innerHTML='<div class="wrapper"><div class="wrapped">'+td.innerHTML+'</div></div>';}}renderersexample, if your data is a 2-D array:{1:'html',2:'html'}or if your data is list of dict:{"front":'html',"back":'html'}Enabling Image, HTML and Markdown rendererThis can be done in Python side, by converting everything to HTML. Just useany markdown for Python library.frommarkdownimportmarkdownimportbase64image_html=f'<img src="{image_url}" width=100 />'image_html2=f'<img src="data:image/png;base64,{base64.b64encode(image_bytes).decode()}" />'markdown_html=markdown(markdown_raw)Any then,PagedViewer(data=data_matrix,renderers={"image_field":"html","html_field":"html","markdown_field":"html"})ScreenshotsRelated projectshtmlviewer- similar in concept to this project, but does not use HandsOnTable.jsTinyDB-viewer- uses HandsOnTable.js and also allow editing in Jupyter Notebook.LicenseThis software includeshandsontable.js, which is MIT-licensed.
Package: py-hangul-checker
py-hangul-checkerPython implementation of Hanhul (Korean Language) Spell Checker설치법$pipinstallpy-hangul-checker사용법>>>fromhangul_checkerimportKoreanSpellChecker>>>sentence_to_be_checked="간편 하게 쓰세요!">>>ksc=KoreanSpellChecker()>>>res=ksc.check_spelling(sentence_to_be_checked)>>>res"간편하게 쓰세요!"
Package: pyhank
PyHank - Quasi-Discrete Hankel Transforms for PythonEdward RogersPyHank is a python implementation of the quasi-discrete Hankel transform as developed by Manuel Guizar-Sicairos and Julio C. Guitierrez-Vega"Computation of quasi-discrete Hankel transforms of the integer order for propagating optical wave fields"Manuel Guizar-Sicairos and Julio C. Guitierrez-Vega
J. Opt. Soc. Am. A21(1) 53-58 (2004)It was designed for use primarily in cases where a discrete Hankel transform is required, similar to the FFT for a Fourier transform. It operates on functions stored in NumPy arrays. If you want an Hankel transform that operates on a callable function, you may be interested inhankelby Steven Murray.I have used this code extensively for beam-propagation-method calculations of radially-symmetric beams. In the radially symmetric case, the 2D FFT over x and y that would be used in a non-symmetric system is replaced by a 1D QDHT over r, making the computational load much lighter and allowing bigger simulations.PyHank was inspired by Adam Wyatt'sMatlab versionwhich I used for many years, before moving to Python and needing my own implementation. It aims to simplify the interface (using Python's object-oriented approach) and utilise existing NumPy/SciPy functions wherever possible.It has both a simple single-shot interface, and a more advanced approach that speeds up computation significantly if making multiple transforms on the same grid.Contributions and comments are welcome using Github at:http://github.com/etfrogers/pyhankInstallationInstallation can simply be done from pip.
PyHank requires numpy and scipy, but these will be installed by pip if necessary.pip install pyhankFor building the docs, the following are required:sphinx-gallery >= 0.7matplotlib >= 3.2For development, and running the tests, the following are recommended:pytest ~= 5.4.3flake8 ~= 3.8.3pytest-flake8 ~= 1.0.6pytest-cov ~= 2.10.0Bugs & ContributionPlease use Github to report bugs, feature requests and submit your code:http://github.com/etfrogers/pyhankDocumentationThe documentation for PyHank can be found atRead the docsUsageSee theUsage examples at ReadTheDocs
Package: pyhanko-certvalidator
certvalidatorThis library started as a fork ofwbond/certvalidatorwith patches forpyHanko, but has since diverged considerably from its parent repository.Bugs and questions regarding this library should be asked in thepyHanko repositoryrather than here.pyhanko-certvalidatoris a Python library for validating X.509 certificates paths. It supports various
options, including: validation at a specific moment in time, whitelisting and revocation checks.FeaturesCurrent ReleaseInstallationLicenseDocumentationContinuous IntegrationTestingFeaturesX.509 path buildingX.509 basic path validationSignaturesRSA (including PSS padding), DSA, ECDSA and EdDSA algorithms.Name chainingValidity datesBasic constraints extensionCA flagPath length constraintKey usage extensionExtended key usage extensionCertificate policiesPolicy constraintsPolicy mappingInhibit anyPolicyFailure on unknown/unsupported critical extensionsTLS/SSL server validationWhitelisting certificatesBlacklisting hash algorithmsRevocation checksCRLsIndirect CRLsDelta CRLsOCSP checksDelegated OCSP respondersDisable, require or allow soft failuresCaching of CRLs/OCSP responsesCRL and OCSP HTTP clientsPoint-in-time validationName constraintsAttribute certificate supportCurrent Release-changelogDependenciesasn1cryptocryptographyuritoolsoscryptorequestsoraiohttp(use the latter for more efficient asyncio, requires resource management)Python 3.7 or higherNote on compatibilityStarting withpyhanko-certvalidatorversion0.17.0, the library has been refactored to use asynchronous I/O as much as possible. Most high-level API entrypoints can still be used synchronously, but have been deprecated in favour of their asyncio equivalents.
As part of this move, the OCSP and CRL clients now have two separate implementations: arequests-based one, and anaiohttp-based one. The latter is probably more performant, but requires more resource management efforts on the caller's part, which was impossible to implement without making major breaking changes to the public API that would make the migration path more complicated. Therefore, therequests-based fetcher will remain the default for the time being.Installationpipinstallpyhanko-certvalidatorLicensecertvalidatoris licensed under the terms of the MIT license. See theLICENSEfile for the exact license text.TestingTest frameworkTests are written usingpytestand require an asynchronous test case backend
such aspytest-asyncio.Test casesThe test cases for the library are comprised of:Public Key Interoperability Test Suite from NISTOCSP tests from OpenSSLVarious certificates generated for TLS certificate validationExisting releases can be found athttps://pypi.org/project/pyhanko-certvalidator.
Package: pyHanoi
pyHanoi is a Python module which uses an iterative approach to solve the “Towers of Hanoi” game.
But instead of running through the shortest possible solution, pyHanoi offers the option to stop the game after a defined move or a defined number of moves and to show the state of the game at this stage. After that, game can be continued.
pyHanoi works with Python 2.6, 2.7 and 3.
Package: pyhanzi
pyhanzi发布python3-mvenvpyhanzi-venv/sourcepyhanzi-venv/bin/activate.fish# 调试好之后python3-mpipinstall--upgradepip-ihttps://mirrors.aliyun.com/pypi/simple/
pip3install-ihttps://mirrors.aliyun.com/pypi/simple/setuptoolswheel
python3setup.pysdistbdist_wheel

pip3freeze>requirements.txt# requirements添加一个peppercornecho'peppercorn'>>requirements.txt
pip3download-rrequirements.txt-ihttps://mirrors.aliyun.com/pypi/simple/-ddist/cddist/
dir2pi-S.
scp-rsimple/root@39.97.232.223:/root/pypi/
pip3install-ihttp://www.hohohaha.cn:8000/simple/pyhanzi==0.0.2--trusted-hostwww.hohohaha.cn上传到pypi# python3 -m venv pyhanzi-venv/sourcepyhanzi-venv/bin/activate.fish
rm-rfdist/*
python3setup.pysdistbdist_wheel
pip3install-ihttps://mirrors.aliyun.com/pypi/simple/twine
python3-mtwineuploaddist/*安装pip3install-ihttps://pypi.python.org/simplepyhanzi==0.0.9
Package: pyhap
The project is on early stage, the API may change. Use version pinning to prevent unexpected changes.RequirementsPython 3.6+cryptography <https://pypi.python.org/pypi/cryptography>ed25519 <https://pypi.python.org/pypi/ed25519>zeroconf <https://pypi.python.org/pypi/zeroconf>Installation$ pip install pyhapOr add pyhap to your application’srequirements.txt/setup.py/Pipfile.UsageCheckexamples <https://github.com/condemil/pyhap/tree/master/examples>
Package: pyhapi
pyhapiObject-Oriented Python Wrapper for Houdini Engine's C APINote that this is 3rd party binding, not official.DocumentationPlease visitpyhapi documentation.InstallYou could use either (a) pip or (b) clone and install.option a.1 setup PATHFor Windows, runpowershell ./sethoupath.ps1it should add houdini's dsolib and bin directory to PATH.For LinuxAdd/opt/hfs<version>/dsolib/to LD_LIBRARY_PATHExample:export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/opt/hfs17.5/dsolib/option a.2 install through PyPI$ pip install pyhapioption bClone this repo and runpython setup.py installSupported PlatformsWindowsLinuxDependencyPython: >3.6Numpy: >= 1.15Houdini >= 17.5License supported:Houdini FXHoudini CoreHoudini EngineLicense NOT supported:Houdini Engine IndieHoudini IndieHoudini ApprenticeFeaturesInstantiate node/HDANode connect operationNode parameter get/setNode async cookingMarshall in/out curveMarshall in/out meshMarshall in/out heightfieldSessionPool and task-based processingFollowing feature in Houdini Engine is NOT supported yet:Marshall in/out volumePDG executionExample UsagePlease see documentation for detailed tutorial.  ****Create a sessionimport pyhapi as ph
session = ph.HSessionManager.get_or_create_default_session()See more inExample: node_networks_operationsInstantiate a HDAhda_asset = ph.HAsset(session, "hda/FourShapes.hda")
asset_node = hda_asset.instantiate(node_name="TestObject").cook()Set parameter of nodeasset_node.set_param_value("seed", 1.0)
asset_node.set_param_value("foo_attrib", "foo_str")
asset_node.press_button("foo_execute")See more inExample: hda_params_getsetExample: hparms_getsetSave HIP filesession.save_hip("debug.hip")Marshall datasee more inExample: curve_marshall_inputExample: curve_marshall_outputExample: mesh_marshall_inputExample: mesh_marshall_outputExample: heightfield_marshal_inputExample: heightfield_marshal_outputSession PoolProducer/Consumersession_pool = ph.HSessionManager.get_or_create_session_pool()

session_pool.run_on_task_producer(producer)Example: multisession_producerBatch Runsession_pool = ph.HSessionManager.get_or_create_session_pool()

session_pool.enqueue_task(session_task, i, j)

session_pool.run_all_tasks()Example: multisession_runThreaded Task Producersession_pool = ph.HSessionManager.get_or_create_session_pool()

session_pool.run_task_consumer_on_background()

executor = ThreadPoolExecutor(max_workers=4)
for i in range(0,4):
    executor.submit(producer, i)Example: multisession_producer_threadedFlask Server DemoExample: server_demo
Package: pyhap-maxcube
Beta! pyhap-maxcubeHAP-pythonAccessories fore-Q3MAX! devices, e.g. Cube and Thermostat.You can easily discover and add MAX! devices to your Home app and set the temperature.Installpip install pyhap-maxcubeUsagefrompyhap.accessory_driverimportAccessoryDriverfrompyhap.accessories.maxcubeimportMaxBridge# The MAX! Cube addressMAX_ADDR='192.168.1.247'MAX_PORT=62910# Run HAP-python on port 51826driver=AccessoryDriver(port=51826)# Expose the MaxBridge accessory - it will discover the MAX! devices and create# accessories for it.driver.add_accessory(accessory=MaxBridge(MAX_ADDR,MAX_PORT,driver,'MaxBridge'))# Start it!driver.start()
Package: pyHappyOrNot
# pyHappyOrNotA wrapper around the HappyOrNot API.## Installationpip install pyHappyOrNot## Usage` python import pyHappyOrNot r = pyHappyOrNot.pyHappyOrNot.HappyOrNot() print(r.results) `## APIresults: A JSON object of FoldersgetJSON(): A JSON object of Folders including Survey Results
Package: pyhapwol
HomeKit Wake on LAN [Python]Ahap-pythonbased implementation of HomeKit Switch Accessory to send
Wake on LAN magic packets to turn your machines on.Turning the Switch On will result sending a WoL magic packet to the target.The state of the Switch is regulary updated, it will eventually turn off if the machine is not reachable, and turn back on, if the machine can be pinged.You can however manually turn it Off and On again, to trigger a WoL packet, and optionally refresh the stored IP address of the target (that is used for pings).RequirementsRequires at leastPython 3.6. Useshap-pythonfor HomeKit integration,clickfor command line,pyyamlfor configuration,pywolfor sending the Wake on LAN packet, andscapyto
get IP address from MAC, and ping.InstallationYou can usepipto install the package.> pip install pyhapwolAlternatively, check out the source code, and install it locally, or install the dependencies and use> python -m pyhapwolCommand Line OptionsAfter installation, thepyhapwolscript should be available. (You can also fallback topython -m pyhapwol)> pyhapwol --help
Usage: pyhapwol [OPTIONS]

  Start HomeKit Server with specified configuration and state file.

Options:
  -c, --config TEXT    Configuration file to use.  [default: config.yaml]
  -s, --state TEXT     HomeKit State file for persistence.  [default:
                       homekit.state]
  -d, --debug BOOLEAN  Debug messages.
  --help               Show this message and exit.ConfigurationThe configuration is a YAML file:-name:Server Namemac:a0:b1:c2:d3:e4:f5broadcast:192.168.0.1/24# The following values are optional:ip:192.168.0.123interface:eth0port:9-name:Other Servermac:f0:e1:d2:c3:b4:a5broadcast:192.168.0.0/24Thenamewill act as a default name for the Switch Accessory.Themacis the mandatory MAC (hardware) address of the network interface you want to wake up.Thebroadcastis used to resolve the broadcast address of your subnet. You can use an IP address of the subnet, and the netmask. This is passed topywol.Optionalipcan be used in case of fix (or DHCP reserved) addresses. If it is omitted,scapyis used to determine the IP address. In case it is not provided, the IP will be "forgotten" when the switch is turned off, and re-evaluated when it is turned on again.Optionalinterfaceis the network interface to use byscapyin the machine running pyhapwol.Optionalportis the port to send the magic packet to. Default value is 9.CaveatsOnly IPv4 addresses are supported.
You will need root privileges forscapyto send and receive packets to determine the IP from the given MAC address, or to ping the target machine for liveness check.Running With DockerYou can build a docker image with> docker build -t pyhapwol:latest .And run it as> docker run \
  --restart unless-stopped \
  --log-opt max-size=10m \
  --log-opt max-file=3 \
  --network host \
  --volume $PWD/config.yaml:/opt/wol/config.yaml:ro \
  --volume $PWD/homekit.state:/opt/wol/homekit.state \
  pyhapwol:latestNote that it takes some time to compile the cryptography dependency in an ARMv7 Raspberry Pi, or similar.
Package: pyhardware
pyhardwarecombines in one package several data-acquisition protocols:ivi drivers (using the lower level package pyivi)visaserialEach instrument connected to the machine can be autodetected, and assigned a unique logical name.
Graphical tools are provided to configure the different instruments and the way they should
be interfaced.It uses the lower-level package pyivi to communicate with ivi-drivers on the machine. The specificity of this package
is to directly interact with the ivi-framework using comtypes and ctypes. This makes fully use of the interchangeability feature of IVI instruments:
new instruments can be installed in a single click by simply installing the IVI-drivers provided by the manufacturer.pyhardware is part of a higher-level package : pyinstruments, that you might want to check out : it adds-up database-capabilities to store the curves from the instruments in a consistent way.DependenciesPyQt4
Package: pyharmonics
pyharmonicspyharmonics detects harmonic patterns in OHLC candle data for any stock or crypto asset.  Seehttp://www.harmonictrader.comfor more information on harmonic patterns and follow author Scott Carney.InstallationFrom git$ git clone git@github.com:niall-oc/pyharmonics.git
$ cd pyharmonics
$ pip install .
$ cd src
$ python
>>> from pyharmonics.marketdata import BinanceCandleData
...From pypi$ pip install pyharmonics
$ python
>>> from pyharmonics.marketdata import BinanceCandleDataComplete Guidehttps://pyharmonics.readthedocs.io/en/latest/Quick GuideUse the market data features or generate your own market data matching the dataframe schema below.close_time, dts can be omitted>>> from pyharmonics.marketdata import BinanceCandleData
>>> b = BinanceCandleData()
>>> b.get_candles('BTCUSDT', b.MIN_15, 1000)
>>> b.df
>>> b.df
                               open      high       low     close     volume  close_time                       dts
index                                                                                                             
2023-07-09 07:44:59+01:00  30249.04  30267.04  30233.79  30262.33   79.71611  1688885099 2023-07-09 07:44:59+01:00
2023-07-09 07:59:59+01:00  30262.32  30267.87  30235.00  30254.79  136.31718  1688885999 2023-07-09 07:59:59+01:00
2023-07-09 08:14:59+01:00  30254.80  30283.50  30233.33  30283.50  185.04086  1688886899 2023-07-09 08:14:59+01:00
2023-07-09 08:29:59+01:00  30283.50  30283.50  30263.37  30263.37   74.17937  1688887799 2023-07-09 08:29:59+01:00
2023-07-09 08:44:59+01:00  30263.37  30270.09  30243.10  30257.30  121.15791  1688888699 2023-07-09 08:44:59+01:00
...                             ...       ...       ...       ...        ...         ...                       ...
2023-07-19 16:29:59+01:00  29841.37  29902.00  29841.36  29878.00  267.42077  1689780599 2023-07-19 16:29:59+01:00
2023-07-19 16:44:59+01:00  29878.00  29933.00  29866.15  29890.01  245.03318  1689781499 2023-07-19 16:44:59+01:00
2023-07-19 16:59:59+01:00  29890.01  29995.16  29890.00  29956.46  611.16786  1689782399 2023-07-19 16:59:59+01:00
2023-07-19 17:14:59+01:00  29956.46  29979.00  29901.70  29930.57  365.35485  1689783299 2023-07-19 17:14:59+01:00
2023-07-19 17:29:59+01:00  29930.57  29930.57  29870.00  29901.40  244.14513  1689784199 2023-07-19 17:29:59+01:00

[1000 rows x 7 columns]Create a technicals object for further analysis.>>> from pyharmonics.technicals import Technicals
>>> t = Technicals(b.df, b.symbol, b.interval)Search for a harmonic pattern.>>> from pyharmonics.search import MatrixSearch
>>> m = MatrixSearch(t)
>>> m.search()Plot the findings.>>> from pyharmonics.plotter import Plotter
>>> p = Plotter(t, 'BTCUSDT', b.MIN_15)
>>> p.add_matrix_plots(m.get_patterns(family=m.XABCD))
>>> p.show()You will see something like this.See all harmonic patterns.>>> p = Plotter(t, 'BTCUSDT', b.HOUR_1)
>>> p.add_matrix_plots(m.get_patterns())
>>> p.show()You will see something like this.See all forming patterns.>>> m = MatrixSearch(t)
>>> m.forming()
>>> p = Plotter(t, 'BTCUSDT', b.HOUR_1)
>>> p.add_matrix_plots(m.get_patterns(formed=False))
>>> p.show()etc.
Package: pyharmony
pyharmony=======Python library for programmatically using a Logitech Harmony Link or Ultimate Hub.A fork of [bkanuka/pyharmony](https://github.com/bkanuka/pyharmony) with the intent to:- Make pip/setup.py installable.- Unify improvments made in other forks.- Configurable for Harmony Link/Hub differences.- Better practices for project layout.- Better error handling!- Inclusion into Home Assistant (https://home-assistant.io)Protocol--------As the harmony protocol is being worked out, notes are in PROTOCOL.md.Status------* Authentication to Logitech's web service working.* Authentication to harmony device working.* Querying for entire device information* Querying for activity information only* Querying for current activity* Starting Activity* Sending CommandUsage-----Pyharmony - Harmony device control```usage: harmony [-h] (--harmony_ip HARMONY_IP | --discover)[--harmony_port HARMONY_PORT][--loglevel {CRITICAL,ERROR,DEBUG,WARNING,INFO}]{show_config,show_current_activity,start_activity,power_off,sync,send_command}...Pyharmony - Harmony device controlpositional arguments:{show_config,show_current_activity,start_activity,power_off,sync,send_command}show_config         Print the Harmony device configuration.show_current_activityPrint the current activity config.start_activity      Switch to a different activity.power_off           Stop the activity.sync                Sync the harmony.send_command        Send a simple command.optional arguments:-h, --help            show this help message and exit--harmony_port HARMONY_PORTNetwork port that the Harmony is listening on.(default: 5222)--loglevel {CRITICAL,ERROR,DEBUG,WARNING,INFO}Logging level to print to the console. (default: INFO)required arguments:--harmony_ip HARMONY_IPIP Address of the Harmony device. (default: None)OR--discoverRun a network scan to discover hubs```TODO----* Figure out how to detect when the session token expires so we can get a newone.* Figure out a good way of sending commands based on sync state.* Is it possible to update device configuration?
Package: pyHarmonySearch
pyHarmonySearch is a pure Python implementation of the harmony search (HS) global optimization algorithm. HS is a metaheuristic search algorithm that, similar to simulated annealing, tabu, and evolutionary searches, is based on real world phenomena. Specifically, HS mimics a jazz band improvising together. CourtesyWikipedia:In the HS algorithm, each musician (= decision variable) plays (= generates) a note (= a value) for finding a best harmony (= global optimum) all together.pyHarmonySearch supports both continuous and discrete variables and can take advantage of parallel processing usingPython’s built-in multiprocessing module.For more information on pyHarmonySearch, visit theGitHub project page.
Package: py_harpyja
PyInterceptionPyInterception is a Python Method Interception with Dependency Injection implementation.Home PagePyInterception Projecthosted on GitHub.IssuesPyInterception Issues on GitHub.InstallationBy pip commandsudopipinstallpy_interceptionManualFor default python executablegitclonehttps://github.com/moisespsena/py_interception.gitpy_interceptioncdpy_interceptionsudopythonsetup.pyinstallFor another python executablesudopython3setup.pyinstallExamplesSeetestsfor more details.Authors/ContributorsMoises P. Sena <moisespsena@gmail.com>HISTORY1.0 (2012-10-08)Initial release