Saravanan666/pypi-org huggingface dataset:
Package: hikaru-model-26
Version 1.1.1Try it: see Hikaru convert your K8s YAMLRelease notesFull documentation at Read the DocsHikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
a variety of ways:Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
objects loaded from non-Python sources.Hikaru also supports a number of features that aid in the management of
your objects such as searching for specific fields or diffing two instances of a K8s resource.Hikaru includes support for creating ‘watches’ on your objects, providing a means to monitor events
on your provisioned K8s resources.Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
and watches.Finally, Hikaru includes a facility to specify a collection of
resources as an ‘application’, similar in spirit to a Helm chart, and provides the same CRUD,
watch, and management capabilities on the entire application as it does on single resource objects
(full format shifting support to come).This package supports resources from the Kubernetes Python client version 26.x. It depends on thehikaru-corepackage which will be installed automatically when this packages is installed. This package
will work with any version of the Kubernetes Python client >= 26.x; if you need to constrain which release
is installed then you should establish your own requirement limts on the Kubernetes Python client package.See README-core.rst for the main README and links to overall documentation.AboutHikaru is Mr. Sulu’s first name, a famed fictional helmsman.
Package: hikaru-model-27
Version 1.1.1Try it: see Hikaru convert your K8s YAMLRelease notesFull documentation at Read the DocsHikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
a variety of ways:Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
objects loaded from non-Python sources.Hikaru also supports a number of features that aid in the management of
your objects such as searching for specific fields or diffing two instances of a K8s resource.Hikaru includes support for creating ‘watches’ on your objects, providing a means to monitor events
on your provisioned K8s resources.Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
and watches.Finally, Hikaru includes a facility to specify a collection of
resources as an ‘application’, similar in spirit to a Helm chart, and provides the same CRUD,
watch, and management capabilities on the entire application as it does on single resource objects
(full format shifting support to come).This package provides model classes to create resources through the Kubernetes Python client version 27.x.
It depends on thehikaru-corepackage which will be installed automatically when this packages is installed. This package
will work with any version of the Kubernetes Python client >= 27.x; if you need to constrain which release
is installed then you should establish your own requirement limts on the Kubernetes Python client package.AboutHikaru is Mr. Sulu’s first name, a famed fictional helmsman.
Package: hikaru-model-28
Version 1.1.0Try it: see Hikaru convert your K8s YAMLRelease notesFull documentation at Read the DocsHikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
a variety of ways:Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
objects loaded from non-Python sources.Hikaru also supports a number of features that aid in the management of
your objects such as searching for specific fields or diffing two instances of a K8s resource.Hikaru includes support for creating ‘watches’ on your objects, providing a means to monitor events
on your provisioned K8s resources.Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
and watches.Finally, Hikaru includes a facility to specify a collection of
resources as an ‘application’, similar in spirit to a Helm chart, and provides the same CRUD,
watch, and management capabilities on the entire application as it does on single resource objects
(full format shifting support to come).This package provides model classes to create resources through the Kubernetes Python client version 28.x.
It depends on thehikaru-corepackage which will be installed automatically when this packages is installed. This package
will work with any version of the Kubernetes Python client >= 28.x; if you need to constrain which release
is installed then you should establish your own requirement limits on the Kubernetes Python client package.AboutHikaru is Mr. Sulu’s first name, a famed fictional helmsman.
Package: hikaxpro
Hikvision AX Pro ISAPI IntegrationWrapper for hikvision ax pro alarm kit ISAPI commands.InstallationUse the package managerpipto install hikaxpro.pipinstallhikaxproUsagefromhikaxproimportHikAxProaxpro=HikAxPro("{host}","{username}","{password}")# returns 'True or False'axpro.arm_away()#returns 'True or False'axpro.disarm()# returns 'True or False'axpro.arm_home()axpro.disarm()
Package: hikconnect
Usagefromhikconnect.apiimportHikConnectasyncwithHikConnect()asapi:awaitapi.login("foo","bar")devices=[deviceasyncfordeviceinapi.get_devices()]print(devices)# [{#   'id': 'DS-XXXXXX-YYYYYYYYYYYYYYYYYYYYYYYYY',#   'name': 'DS-XXXXXX-Y(ZZZZZZZZZ)',#   'serial': 'ZZZZZZZZZ',#   'type': 'DS-XXXXXX-Y',#   'version': 'V1.2.3 build 123456',#   'locks': {1: 2, 2: 0, 3: 1}# }]# locks data means (guessing): <channel number>: <number of locks connected>my_device_serial=devices[0]["serial"]cameras=[cameraasyncforcamerainapi.get_cameras(my_device_serial)]print(cameras)# [#   {'id': '4203fd7c5f89ce96f8ff0adfdbe8b731', 'name': 'foo', 'channel_number': 1, 'signal_status': 1, 'is_shown': 0},#   {'id': 'cd72bc923956952194468738123b7a5e', 'name': 'bar', 'channel_number': 2, 'signal_status': 1, 'is_shown': 1},#   {'id': 'd2a2057d853438d9a5b4954baec136e3', 'name': 'baz', 'channel_number': 3, 'signal_status': 0, 'is_shown': 0}# ]call_status=awaitapi.get_call_status(my_device_serial)print(call_status)# {#   'status': 'idle',#   'info': {#     'building_number': 0,#     'floor_number': 0,#     'zone_number': 0,#     'unit_number': 0,#     'device_number': 0,#     'device_type': 0,#     'lock_number': 0#   }# }# can be "idle" / "ringing" / "call in progress" - see hikconnect/api.py:45# Unlock deviceawaitapi.unlock(my_device_serial,1)# Cancel call for deviceawaitapi.cancel_call(my_device_serial)# call this periodically at least once per 30 mins!ifapi.is_refresh_login_needed():awaitapi.refresh_login()If you are new toasyncPython, you simply need to wrap your code in a construction like this:importasyncioasyncdefmain():# put the original code containing `async` keywords hereasyncio.run(main())More infoin theasyncdocs.
Package: hiker
HikerNavigating nested python objects with ease.This package ships a lot of functionality you might recognise from python'sdictorlistmethods, like getters and setters, the update function and the
likes, but for nested objects consiting ofdicts andlists. You can specify
what part of you nested object you want by using a '/deep/path/syntax/' and can
update only branches of your objects without overwriting of deleting
unspecified paths.The basis for all this is thewalkfunction. It accepts your nested object
and calls a function on all leaf variables.Exampledol = {'a': [1, 2], 'b': {'c': 3, 'd': 4}}

def fn(val):
    return val**2

result = walk(dol, fn)
print(result)  # {'a': [1, 4], 'b': {'c': 9, 'd': 16}}
print(dol)  # {'a': [1, 2], 'b': {'c': 3, 'd': 4}}

result = walk(dol, fn, inplace=True)
print(result)  # {'a': [1, 4], 'b': {'c': 9, 'd': 16}}
print(dol)  # {'a': [1, 4], 'b': {'c': 9, 'd': 16}}Below you can find a table which compareshiker's functionality with those of
python'sdictandlist.hikerdictlistExamplewalk--retrievedict[key],dict.get()list[index]retrieve({'a': [1, 2]}, 'a/0]) => 1pop_keypathdict.pop()list.popset_defaultdict.setdefault()set_valuedict[key] = val,list[index] = valcontains_keykey in dict0 <= index < len(list)updatedict.update()get_lead_namesdict.keys()
Package: hikerapi
Hikerapi client, for Python 3Installationpip install hikerapiUsageCreate a tokenhttps://hikerapi.com/tokensand copy "Access key"fromhikerapiimportClientcl=Client(token="<ACCESS_KEY>")user=cl.user_by_username_v2("instagram")print(user)fromhikerapiimportAsyncClientcl=AsyncClient(token="<ACCESS_KEY>")user=awaitcl.user_by_username_v2("instagram")print(user)Run testsHIKERAPI_TOKEN=<token> pytest -v tests.py

HIKERAPI_TOKEN=<token> pytest -v tests.py::test_search_music
Package: hikka-filters
Hikka FiltersFilters for updates-handlers for Telegram UserBotHikkaInstallInstall via GitHub:pip3installhttps://github.com/Den4ikSuperOstryyPer4ik/hikka_filters/archive/main.zip--upgradeStable version from PyPi:pip3installhikka-filtersFor Windows:pip3>pipUsage# requires: hikka-filters>=0.2.0from..importloader,utilsfromhikka_filtersimportcheck_filters,user,chat,text,media,content_types,args@loader.tdsclassTestModule(loader.Module):"""Test module for `hikka-filters` library"""strings={"name":"TestHikkaModule"}@loader.watcher()@check_filters(media)asyncdefmedia_watcher(self,message):"""Watcher for messages with media"""...@loader.watcher()@check_filters(content_types("forwarded")&text(startswith="!",endswith="cmd",lower=True))asyncdefforwarded_cmd_watcher(self,message):"""Watcher for forwarded messages with text starstwith "!" and endswith "cmd" """...@loader.command()@check_filters(args)asyncdefcommand(self,message):"""Command with args: `(args = message.args = utils.get_args_raw(message))`"""args=message.args...@loader.watcher()@check_filters(chat([ID1,ID2,ID3]))asyncdefwatcher_in_chats_with_ids(self,message):"""Watcher for messages in chats with IDs"""...@loader.watcher()@check_filters(user([ID1,ID2,ID3]))asyncdefwatcher_for_sended_users_with_ids(self,message):"""Watcher for users, sended message, by IDs"""...File hikka_test_module.pyThanks@hikariatamafor making a great userbot for Telegram:Hikka!
Package: hiko
hikoSeamlessly run simple functions in parallel usingDaskand other useful toolsInstalationTo install newest version from PYPI:pipinstallhikoSample UsecasesDaskfromhiko.daskimportdaskify@daskify()defsquared(x):returnx**2squared_output=squared([iforiinrange(10)])It is also possible to provide cluster address if Dask is running on multiple machines. For example:@daskify("111.111.111.1:8797")defsquared(x):returnx**2timeLittle utility to provide execution time using decoratorfromhiko.timeimporttimeify@timeify(True)defsquared(x):returnx**2# if True is provided, then execution time returned alongside the resultresult,execution_time=squared(5)IDEASData Query / Data InjectionStandard Dask FunctionsAutomated documentationWrite more testsModuleshiko
timedatadask
decoratorsfunctionsspark
decoratorsfunctionsdatapipelines
Package: hiku
Hiku is a library to implement Graph APIs. Essential GraphQL support included.Installation$pip3installhikuBug fixes and new features are frequently published via release candidates:$pip3install--upgrade--prehikuDocumentationReaddocumentationOptional dependenciesgraphql-core- for GraphQL supportprotobuf- for Protobuf supportsqlalchemy- for SQLAlchemy support as a data-sourceaiopg- for async PostgreSQL support withaiopgasyncpg- for async PostgreSQL support withasyncpgprometheus-client- for Prometheus metrics supportsentry-sdk- for Sentry tracing supportHighlightsNot coupled to a single specific query languageFlexibility in result serialization, including binary formatsNatively uses normalized result representation, without data duplicationAll concurrency models supported: coroutines, threadsParallel query executionNo data under-fetching or over-fetching betweenclient<->serverand
betweenserver<->databaseNoN+1problems by designIntroduces a concept ofTwo-Level Graphin order to decouple data-sources
and business-logicQuick exampleGraph definition:fromhiku.graphimportGraph,Root,Node,Field,Linkfromhiku.typesimportString,Sequence,TypeRefdefcharacters_data(fields,ids):data={1:{'name':'James T. Kirk','species':'Human'},2:{'name':'Spock','species':'Vulcan/Human'},3:{'name':'Leonard McCoy','species':'Human'},}return[[data[i][f.name]forfinfields]foriinids]defcharacters_link():return[1,2,3]GRAPH=Graph([Node('Character',[Field('name',String,characters_data),Field('species',String,characters_data),]),Root([Link('characters',Sequence[TypeRef['Character']],characters_link,requires=None),]),])Query:fromhiku.engineimportEnginefromhiku.builderimportQ,buildfromhiku.executors.syncimportSyncExecutorengine=Engine(SyncExecutor())result=engine.execute_query(GRAPH,build([Q.characters[Q.name,Q.species,],]))# use result in your codeforcharacterinresult.characters:print(character.name,'-',character.species)Output:James T. Kirk - Human
Spock - Vulcan/Human
Leonard McCoy - HumanContributingUseToxin order to test and lint your changes.
Package: hikvision
IntroductionThis is a very basic python module providing a basic python
interface to interact with a Hikvision IP CameraThis is licensed under the MIT license.Getting startedThis module is tested against firmware 5.2.0.
It may work on older versions, but that has not been tested.For further info on  the camera API's see:
CGI API Guide:http://bit.ly/1RuyUuFDevelopmenthikvision is hosted by Github athttps://github.com/fbradyirl/hikvisionCI run after commit:toxInstallgitclone--recursivegit@github.com:fbradyirl/hikvision.gitcdhikvision# NOTE: You might need administrator privileges to install python modules.pipinstall-rrequirements.txtpipinstall-e.UsageVariables:importhikvision.api# This will use http by default (not https)# pass False to the digest_auth parameter of CreateDevice to fallback to basic auth# (note that basic auth and http without ssl are inherently insecure)# more recent hikvision firmwares default to turning basic auth off# (and that's a good idea for security)hik_camera=hikvision.api.CreateDevice('192.168.2.5',username='admin',password='12345')hik_camera.enable_motion_detection()hik_camera.disable_motion_detection()hik_camera.is_motion_detection_enabled()host(*Required) : This is the IP address of your Hikvision camera. Example: 192.168.1.32username(*Required) : Your Hikvision camera usernamepassword(*Required) : Your Hikvision camera usernameHistory2.0.3 (07-09-2020)Updated to use travis, tox, and some other cosmetic improvements.2.0.4 (2020-12-08)Switch pipeline to Github actions
Package: hikvision_client
This is a graphical client for use with Hikvision DVR systems which
support RTSP.The Program reads a config file from ~/.hikvision-client/cam_config,
which defines which cameras the program can access.Afterwards, the user is prompted for a username and password, which is
then used to authenticate the connection to the Hikvision DVRThe program has been tested with the Hikvision DS-8016HFI-ST, it should
however be able to connect to other RTSP-enabled DVRs as well. Or any
RTSP feed in general.InstallationTo install the program, either download the source and run# python setup.py installor, if you have pip installed, run# pip install hikvision_clientThis should also install all python dependencies required by the programThe program makes use of the VLC Media Player, and as such it is
required for VLC to be installed for this program to function correctly.Writing the Config FileThe program requires a configuration file located at
~/.hikvision-client/cam_config. It is a plain text file. To add a
camera, add a new line in the following format:Camera_Name#####Camera_LinkThe camera link is formatted like this:<domain>/h264/chX/main/av_stream  (analog)
<domain>/Streaming/Channels/X01   (digital)whereas ‘X’ is the channel number of the camera.
Package: hikvision-isapi-py
hikvision-isapi-pySimple client to interact with Hikvision devices using the ISAPI protocol.Source code:https://github.com/jackblk/hikvision-isapi-pyIgnore SSL verificationCan be useful if you are using self-signed certificates or the web server
certificate is not trusted by your client.Set the environment variableVERIFY_SSLtofalse(anything buttruewill skip the check)
Package: hikvision-recover
Command-line tool for generating recovery codes for Hikvision IP CamerasNormally, to reset a hikvision camera you contact their support department to generate a recovery code.
This package will allow you to generate the proper recovery code without contacting support.
To do this you need the camera’s serial number and current time reported by the camera.InstallationYou can install via pip`bash pip installhikvision-recover`UsageAfter installing via pip, the command line entry pointhikvision-recoveris available. The syntax for the command ishikvision-recover serial year month daye.g.:hikvision-recover DS-ABC1234567-HIJKLMNOPQRS10987654321 2017 01 25positional arguments:serial:      Camera Serial Numberyear:        4 digit year of current camera timemonth:       2 digit month of current camera timeday:         2 digit day of current camera timeoptional arguments:-h,--helpshow help message and exitvia scriptYou can also use this package directly in a script instead of via the command line.fromhikvision_recover.recoverimportget_codeserial="DS-ABC1234567-HIJKLMNOPQRS10987654321"year="2017"month="01"day="25"recovery_code=get_code(serial,year,month,day)print(recovery_code)
Package: hikyuu
Hikyuu Quant Framework是一款基于C++/Python的开源量化交易研究框架，用于策略分析及回测（仅受限于数据，如有数据也可用于期货等）。其核心思想基于当前成熟的系统化交易方法，将整个系统化交易抽象为由市场环境判断策略、系统有效条件、信号指示器、止损/止盈策略、资金管理策略、盈利目标策略、移滑价差算法七大组件，你可以分别构建这些组件的策略资产库，在实际研究中对它们自由组合来观察系统的有效性、稳定性以及单一种类策略的效果。祝贺 HIKYUU 入选 GITEE 最有价值开源项目 GVP给作者加点油，每天扫扫红包，或者请作者喝杯咖啡示例：#创建模拟交易账户进行回测，初始资金30万
my_tm = crtTM(init_cash = 300000)

#创建信号指示器（以5日EMA为快线，5日EMA自身的10日EMA作为慢线，快线向上穿越慢线时买入，反之卖出）
my_sg = SG_Flex(EMA(CLOSE(), n=5), slow_n=10)

#固定每次买入1000股
my_mm = MM_FixedCount(1000)

#创建交易系统并运行
sys = SYS_Simple(tm = my_tm, sg = my_sg, mm = my_mm)
sys.run(sm['sz000001'], Query(-150))完整示例参见：https://nbviewer.jupyter.org/github/fasiondog/hikyuu/blob/master/hikyuu/examples/notebook/000-Index.ipynb?flush_cache=True为什么选择 Hikyuu？组合灵活，分类构建策略资产库Hikyuu对系统化交易方法进行了良好的抽象，包含了九大策略组件：市场环境判断策略、系统有效条件、信号指示器、止损/止盈策略、资金管理策略、盈利目标策略、移滑价差算法、交易对象选择策略、资金分配策略。可以在此基础上构建自己的策略库，并进行灵活的组合和测试。在进行策略探索时，可以更加专注于某一方面的策略性能与影响。其主要功能模块如下：性能保障，打造自己的专属应用目前项目包含了3个主要组成部分：基于C++的核心库、对C++进行包装的Python库(hikyuu)、基于Python的交互式工具。C++核心库，提供了整体的策略框架，在保证性能的同时，已经考虑了对多线程和多核处理的支持，在未来追求更高运算速度提供便利。C++核心库，可以单独剥离使用，自行构建自己的客户端工具。Python库（hikyuu），提供了对C++库的包装，同时集成了talib库（如TA_SMA，对应talib.SMA），可以与numpy、pandas数据结构进行互相转换，为使用其他成熟的python数据分析工具提供了便利。hikyuu.interactive 交互式探索工具，提供了K线、指标、系统信号等的基本绘图功能，用于对量化策略的探索和回测。代码简洁，探索更便捷、自由同时支持面向对象和命令行编程范式。其中，命令行在进行策略探索时，代码简洁、探索更便捷、自由。安全、自由、隐私，搭建自己的专属云量化平台结合 Python + Jupyter 的强大能力与云服务器，可以搭建自己专属的云量化平台。将Jupyter部署在云服务器上，随时随地的访问自己的云平台，即刻实现自己新的想法，如下图所示通过手机访问自己的云平台。结合Python强大成熟的数据分析、人工智能工具（如 numpy、scipy、pandas、TensorFlow)搭建更强大的人工智能平台。数据存储方式可扩展目前支持本地HDF5格式、MySQL存储。默认使用HDF5，数据文件体积小、速度更快、备份更便利。截止至2017年4月21日，沪市日线数据文件149M、深市日线数据文件184M、5分钟线数据各不到2G。
Package: hi-lasso
Hi-LASSOHi-LASSO(High-Dimensional LASSO) can theoretically improves a LASSO model providing better performance of both prediction and feature selection on extremely
high-dimensional data.  Hi-LASSO alleviates bias introduced from bootstrapping, refines importance scores, improves the performance taking advantage of
global oracle property, provides a statistical strategy to determine the number of bootstrapping, and allows tests of significance for feature selection with
appropriate distribution.  In Hi-LASSO will be applied to Use the pool of the python library to process parallel multiprocessing to reduce the time required for
the model.InstallationHi-LASSOsupport Python 3.6+, Additionally, you will neednumpy,scipy,tqdmandglmnet.
However, these packages should be installed automatically when installing this codebase.Hi-LASSOis available through PyPI and can easily be installed with a
pip install::pip install hi_lassoDocumentationRead the documentation onreadthedocsQuick Start#Data loadimportpandasaspdX=pd.read_csv('https://raw.githubusercontent.com/datax-lab/Hi-LASSO/master/simulation_data/X.csv')y=pd.read_csv('https://raw.githubusercontent.com/datax-lab/Hi-LASSO/master/simulation_data/y.csv')#General Usagefromhi_lasso.hi_lassoimportHiLasso# Create a HiLasso modelhilasso=HiLasso(q1='auto',q2='auto',L=30,alpha=0.05,logistic=False,random_state=None,parallel=False,n_jobs=None)# Fit the modelhilasso.fit(X,y,sample_weight=None)# Show the coefficientshilasso.coef_
Package: hi-lasso-spark
Hi-LASSO_sparkHi-LASSO_Spark(High-Demensinal LASSO Spark) is to improve the LASSO solutions for extremely high-dimensional data using pyspark.
PySpark is the Python API written in python to support Apache Spark.
Apache Spark is a distributed framework that can handle Big Data analysis.
Spark is basically a computational engine, that works with huge sets of data by processing them in parallel and batch systems.InstallationHi-LASSO_Sparksupport Python 3.6+, Additionally, you will neednumpy,scipy, andglmnet.Hi-LASSO_sparkis available through PyPI and can easily be installed with a
pip install::pip install hi_lasso_sparkDocumentationRead the documentation onreadthedocsQuick Start# Data loadimportpandasaspdX=pd.read_csv('simulation_data_x.csv')y=pd.read_csv('simulation_data_y.csv')# General Usagefromhi_lasso_spark.Hi_LASSO_sparkimportHiLASSO_Spark# Create a HiLasso modelmodel=HiLASSO_Spark(X,y,alpha=0.05,q1='auto',q2='auto',L=30,cv=5,node='auto',logistic=False)# Fit the modelmodel.fit()# Show the coefficientsmodel.coef_# Show the p-valuesmodel.p_values_# Show the selected variablemodel.selected_var_
Package: hilearn
HiLearnA small library of machine learning models and utility & plotting functions:a set of utility functions, e.g., wrap function for cross-validation on
regression and classification modelsa set of small models, e.g., mixture of linear regression modela set of plotting functions, e.g.,corr_plot,ROC_curve,PR_curveHow to install?Easy install withpipbypip install hilearnfor released version or the
latest version on github (less stable though)pipinstall-Ugit+https://github.com/huangyh09/hilearnIf you don’t have the root permission, add--user.DocumentationSee thedocumentationfor how to use, e.g.,cross-validationandplotting functions.