Saravanan666/pypi-org huggingface dataset:
Package: erizo
Elastic multi-component interpolation of ground displacementDocumentation|Documentation (dev version)|Contact|
Part of theFatiando a TerraprojectDisclaimer🚨This package is in early stages of design and implementation.🚨We welcome any feedback and ideas!
Let us know by submittingissues on Githubor send us a message on ourSlack chatroom.AboutErizo is a Python package for interpolation (gridding) of multi-component
ground displacement measurements (from GPS/GNSS or InSAR, for example).
It uses an elastic Green’s functions approach for interpolation based on
[Verde](https://www.fatiando.org/verde).Project goals2- and 3-component velocity/displacement interpolation.Use simple elastic Green’s functions.Include cross-validated versions of all interpolators.Provide an interface similar to scikit-learn for machine learning style
interpolation.Contacting UsMost discussion happenson Github.
Feel free toopen an issueor comment
on any open issue or pull request.We havechat room on Slackwhere you can ask questions and leave comments.ContributingCode of conductPlease note that this project is released with aContributor Code of Conduct.
By participating in this project you agree to abide by its terms.Contributing GuidelinesPlease read ourContributing Guideto see how you can help and give feedback.Imposter syndrome disclaimerWe want your help.No, really.There may be a little voice inside your head that is telling you that you’re
not ready to be an open source contributor; that your skills aren’t nearly good
enough to contribute.
What could you possibly offer?We assure you that the little voice in your head is wrong.Being a contributor doesn’t just mean writing code.
Equality important contributions include:
writing or proof-reading documentation, suggesting or implementing tests, or
even giving feedback about the project (including giving feedback about the
contribution process).
If you’re coming to the project with fresh eyes, you might see the errors and
assumptions that seasoned contributors have glossed over.
If you can write any code at all, you can contribute code to open source.
We are constantly trying out new skills, making mistakes, and learning from
those mistakes.
That’s how we all improve and we are happy to help others learn.This disclaimer was adapted from theMetPy project.LicenseThis is free software: you can redistribute it and/or modify it under the terms
of theBSD 3-clause License. A copy of this license is provided inLICENSE.txt.Documentation for other versionsDevelopment(reflects themasterbranch on
Github)Latest releasev0.0.1
Package: erlanglib
erlanglib - An Erlang LibraryThis Erlang library provides functions to assist in teletraffic engineering, offering functions based on Erlang formulas. Erlang formulas are widely used in the telecommunications industry for calculating various metrics such as call blocking probability, probability of call queuing, service levels, and more.Table of ContentsInstallationGeneral FunctionsErlang B FunctionsErlang C FunctionsUsageInstallationYou can install erlanglib via pip:pip install erlanglibGeneral Functionsfactorial(n)Calculates the factorial of n.calculate_erlangs(call_duration_hours, calls_per_hour)Given the average call duration in hours and calls initiated per hour, it returns the traffic in Erlangs.calculate_erlangs_seconds(call_duration_seconds, calls_per_second)Given the average call duration in seconds and calls initiated per second, it calculates the traffic in Erlangs in terms of hours.calculate_erlangs_minutes(call_duration_minutes, calls_per_minute)Given the average call duration in minutes and calls initiated per minute, it calculates the traffic in Erlangs in terms of hours.calls_per_second_from_erlangs(erlangs, call_duration_seconds)Given the traffic in Erlangs and average call duration, it calculates the calls initiated per second.call_duration_from_erlangs(erlangs, calls_per_second)Given the traffic in Erlangs and calls initiated per second, it calculates the average call duration in seconds.Erlang B Functionserlang_b(N, A)Calculates the blocking probability using the Erlang B formula.required_channels(A, target_blocking)Given the traffic in Erlangs and a desired blocking probability, it calculates the required number of channels.calculate_erlangs_from_blocking(N, target_blocking)Given the blocking probability and available lines, it calculates the traffic in Erlangs.Erlang C Functionserlang_c(N, A)Calculates the probability that a call is queued using the Erlang C formula.service_level(N, A, Pw, target_time_seconds, AHT_seconds)Given various parameters including the probability a call is queued, it calculates the service level.average_speed_of_answer(N, A, Pw, average_handling_time)Given the probability a call is queued, number of agents, traffic in Erlangs, and average handling time, it calculates the Average Speed of Answer.immediate_answer_percentage(Pw)Given the probability a call is queued, it calculates the percentage of calls answered immediately.occupancy(A, N)Given the traffic in Erlangs and the number of agents, it calculates the agent utilization in percentage.required_agents(N_raw, shrinkage_percentage)Given the raw number of agents and shrinkage percentage, it calculates the number of agents required.UsageTo use this library, simply import the desired functions and utilize them as per the requirements. Each function is accompanied by its detailed documentation, ensuring ease of use.
Package: erlang-py
Provides all encoding and decoding for the Erlang External Term Format
(as defined athttps://erlang.org/doc/apps/erts/erl_ext_dist.html) in a
single Python module.Available as aPython package at
``https://pypi.python.org/pypi/erlang_py/`<https://pypi.python.org/pypi/erlang_py/>`__.Testspython setup.py testAuthorMichael Truog (mjtruog at protonmail dot com)LicenseMIT License
Package: erlenberg-ext
pythonUtils_extSome personal librarys for python. This module is heavier than "erlenberg" so it is separated.Install instructions:pip install erlenberg_extUsage instructions in python program:import erlenberg_ext

cyphertext = erlenberg_ext.simpleCrypt.encrypt('text to encrypt', 'password')
print(cyphertext)

plaintext = erlenberg_ext.simpleCrypt.decrypt(cyphertext, 'password')
print(plaintext)Usage instructions for the specific submodules (e.g. logHandler) can be found in the "information" directory.
Package: erlport
ContentsDescriptionInstallationExamplesNotes for Windows usersFeedbackProject URLs:http://github.com/hdima/erlporthttp://pypi.python.org/pypi/erlport/DescriptionTheerlportPython library implementsErlang external term formatandErlang port
protocolfor easier
integration of Python and Erlang.The library exports the following classes and functions:Port(packet=1, use_stdio=False, compressed=False)- class implementing
port which connects with the corresponding Erlang port. Seeopen_port/2for description ofpacketanduse_stdioarguments.compressedis the zlib
compression level or True for the default of 6.Protocol()- class which simplifies creation of request-response
protocols.Atom(str)- class which represents an Erlang atom.String(unicode | list)- class representing an Erlang string. Must be
used as a wrapper if Unicode string expected instead of a list.BitBinary(str)- class representing an Erlang bitstring whose length in
bits is not a multiple of 8.decode(str)- function to convert binary data into a term.encode(term, compressed=False)- function to convert a term into the
external format.compressedis the zlib compression level or True for the
default of 6.IncompleteData- exception raised bydecode()in case of incomplete
input data.InstallationPrerequisites:Erlang >= R11B-4Python >= 2.4To install the library useeasy_installfromsetuptoolspackage like this:$ easy_install erlportExamplesSeeexamplesdirectory in the source distribution for additional examples.For simple request-response protocol usePortandProtocolon the
Python side like this:from erlport import Port, Protocol

class HelloProtocol(Protocol):

    def handle_hello(self, name):
        return "Hello, %s" % name

if __name__ == "__main__":
    proto = HelloProtocol()
    proto.run(Port(use_stdio=True))On the Erlang side functionhello()can be called like this:-module(hello).
-export([hello/1]).

hello(Name) ->
    Port = open_port({spawn, "python -u hello.py"}, [{packet, 1}, binary]),
    port_command(Port, term_to_binary({hello, Name})),
    receive
        {Port, {data, Data}} ->
            binary_to_term(Data)
    end.Test it in the Erlang shell:1> c(hello).
{ok,hello}
2> hello:hello("Bob").
"Hello, Bob"Notes for Windows usersIt seems Erlang’sopen_portfunction ignoresnouse_stdiooption on
Windows. So thePortclass must be instantiated withuse_stdio=Trueargument.Python must be ran with-uoption to openstdin/stdoutin binary
mode.FeedbackPlease report bugs, offer suggestions or feedback at:Report bugs athttp://github.com/hdima/erlport/issuesEmail me at <dima at hlabs.org>Write or follow me athttp://twitter.com/hdima
Package: ermine
ErmineEasy, fast, stableErmine is designed to provide the user with the greatest possible comfort when creating Rest APIs or entire websites.
Everything is simple and, above all, intuitively designed. No focus on superfluous configurations. Everything works, simply.🔑 Key featuresintuitive, due to the clear designsimple, due to the fast learning curvepractical, through the great editor supportminimalistic, no superfluous functionsWhat is Ermine and what is notErmine is not a HighSpeed framework. Ermine is probably not ready for production. Ermine is a spare time project of mine. Ermine is self-contained. It doesn't need anything, except for an ASGI server. So it's like Starlette.
I would appreciate if you use Ermine, try it and give me your feedback.Participate in ErmineYou are welcome to collaborate on Ermine. However, you should maintain the codestyle, and also follow PEP 8 (the Python style guide).Ermine disadvantagesErmine is still deep in development, which is why some features are still missing.WebsocketsExamplesHere is the most basic example of erminefromermineimportErmine,Requestapp=Ermine()@app.get("/home")asyncdefhome():return"Welcome home"You want to build a RestAPI? No problemfromermineimportErmine,Requestapp=Ermine()templates=FoxTemplates("templates")@app.get("/api")defapi():return{"name":"Leo","age":16}You want to send HTML files? Ermine got your backfromermineimportErmine,Requestfromermine.responsesimportHTMLResponseapp=Ermine()@app.get("/html")asyncdefhome():withopen("home.html","r")asf:data=f.read()returnHTMLResponse(data)You want to use some templates ? You want to load templates? No problem withFuchsfromermineimportErmine,Requestfromermine.templatingimportFoxTemplatesapp=Ermine()templates=FoxTemplates("templates")@app.get("/home")asyncdefhome():returntemplates.render("home.html",name="Leo")Changes incomingJoin ourdiscord!
Package: ernest
ErnestWhat Ernest isA CLI-based tool for making bulk changes to files via Python, partly achieved through syntax trees (for .py files, usingredbaron) and partly through regular expressions.Useful if you're making a load of really boring changes that you can't really do with regexes alone (or only with regexes the length of War and Peace).Named after theNitpickerfrom The Adventure Zone.It was made as part of a refactoring effort for a specific project and as such is pretty limited at the moment - it currently only contains methods for refactoring Python files but it is intended to be extensible.What Ernest isn'tA tool that will fix all your syntax problems.Pulling from any set of code standards - any new refactorings have to definedmanually(though you can pick and choose which ones to apply).Particularly reliable.InstallationpipinstallernestConfigurationYou can override the defaults by making a JSON config file. By default Ernest looks in~/.config/ernest/ernest.jsonbut you can specify a different json file using the--configoption.{"name":"",// the name of the project - used in headers"header":[// added at the top of python files"#!/usr/bin/env python","# encoding: utf-8","This file is part of the {} project",// example of how the name is used""],"imports":{// checks python imports"exclude":[],// do not allow these ever"conditional_exclude":{},// do not allow these submodules from the main module, e.g. {'ernest': 'models'} excludes 'ernest.models' but allows 'ernest.helpers'"conditional_include":{}// allow only these submodules from the main module, e.g. {'ernest': 'models'} allows 'ernest.models' but not 'ernest.helpers'}}You can find an example of the config file in thedatafolder.UsageQuickstarternest/project/pathfixpyGeneral Options--config/path/to/config
--name"My Project"Subcommandsstatsernest[--config/path/to/config][--name"My Project"][/path/to/dir]stats[filetypes]Show statistics for all files:ernest/path/to/dirstatsStats for just (e.g.)txtandmdfiles:ernest/path/to/dirstatstxtmdfixernest[--config/path/to/config][--name"My Project"][/path/to/dir]fix[filetype][fix(es)]Run all fixes for.pyfiles:ernest/path/to/dirfixpyallRun theliteral string quoteanddocstring quotefixes for.pyfiles:ernest/path/to/dirfixpyliteraldocstringContributingPlease feel free to fork, submit pull requests, etc.! It doesn't have to be limited to Python files - that's just how Ernest processes the text.
Package: ernie4us
ERNIE for the Rest of UsTheERNIEmodel is a pre-trained model for natural language processing
from Baidu. ERNIE 2.0 claimedthe top GLUE scoreas of
December 11, 2019. However, ERNIE is implemented in Baidu'sPaddle deep learning frameworkwhereas the rest of us typically use more popular framework, e.g. Tensorflow. This project provides an accessible
package to recreate the ERNIE model in tensorflow initialized with the original ERNIE-trained weights.Installation and UsagesFirst installernie4uspython package viapip:pip install ernie4usCheckout theERNIE4us_demo.ipynbjupyter notebook on how
to load and use the converted model using tensorflow API.Extracting the ERNIE model yourselfFirst download a pre-trained ERNIE 2.0 model in paddle format. The avialable variations and download location
can be found atERNIE's github project.Run theextract_ernie_params.shscript to extract model parameters and copy artifacts:$ cd ~/ERNIE-for-the-rest-of-us
$ tar -C model_artifacts/ERNIE_Large_en_stable-2.0.0/paddle -zxf ~/Downloads/ERNIE_Large_en_stable-2.0.0.tar.gz
$ ./extract_ernie_params.sh
Usage: ./extract_ernie_params.sh ERNIE_MODEL_NAME
  ERNIE_MODEL_NAME the model identifier. Allowed identifiers are
    ERNIE_Base_en_stable-2.0.0
    ERNIE_Large_en_stable-2.0.0
$ ./extract_ernie_params.sh ERNIE_Large_en_stable-2.0.0
# .... some outputs ...
totally 392 persistables
copying artifacts...
total 2621456
-rw-r--r--@ 1 user_x  staff   330B Feb 20 16:36 ERNIE_Large_en_stable-2.0.0_config.json
-rw-r--r--@ 1 user_x  staff   226K Feb 20 16:36 ERNIE_Large_en_stable-2.0.0_vocab.txt
-rw-r--r--  1 user_x  staff   1.2G Feb 20 16:36 ERNIE_Large_en_stable-2.0.0_persistables.pkl
drwxr-xr-x  5 user_x  staff   160B Feb 20 16:36 paddle
ERNIE_Large_en_stable-2.0.0 parameters are exported to ./model_artifacts/ERNIE_Large_en_stable-2.0.0Please note that the extraction script will install a specific version of tensorflow and thus overriding any
current tensorflow version. It is adviced that one sets up a specific virtual environment for this work.After that, one can run theERNIE4us_verification.ipynbJupyter note book to verify
the corresponding ERNIE model recreated in tensorflow produces the same hidden features as the the orginal Paddle
implementation.To use the extracted parameters in the model, put the artifact files in a subfolder named by the model name under the
path that you would be using in theernie4s.load_ernie_modelmethod, e.g.:importernie4us# Extracted ERNIE artifacts in /user/local/lib/ernie4us/ERNIE_Large_en_stable-2.0.0/input_builder,ernie_tf_inputs,ernie_tf_outputs=ernie4us.load_ernie_model(model_name='ERNIE_Large_en_stable-2.0.0',model_path='/user/local/lib/ernie4us')Tensorflow versions supportVersion 0.1.15 of this library supports tensorflow 1.15. Version 2.x works only with tensorflow 2.x.References and CreditsThe modeling codes are adopted from the originalBERTand modified to accept ERNIE parameters as well as migrating to tensorflow 2.0 / Keras.LicenseApache 2.0
Package: erniebot-agent
ERNIE Bot AgentERNIE Bot Agent是由百度飞桨全新推出的大模型智能体(agent)开发框架。基于文心大模型强大的编排能力，并结合飞桨星河社区提供的丰富预置平台化功能，ERNIE Bot Agent旨在成为功能全面且高度可定制的一站式大模型智能体和应用开发框架。特性编排能力: ERNIE Bot Agent 基于文心大模型的 Function Calling 能力实现了多工具编排和自动调度功能，并且允许工具、插件、知识库等不同组件的混合编排。除了自动调度，我们未来还将支持更多的编排模式，例如手动编排、半自动编排，为开发者提供更大的灵活性。组件库: ERNIE Bot Agent 为开发者提供了一个丰富的预置组件库：预置工具：只需一行代码，即可加载使用星河社区工具中心的30+预置工具。这些工具当前主要来自百度AI开发平台和飞桨特色PP系列模型。后续，我们会持续接入更多预置工具，也欢迎社区贡献。此外，工具模块也支持用户灵活自定义本地和远程工具。知识库：提供了开箱即用的基于文心百中的平台化知识库, 并允许开发者在二次开发的场景下使用langchain、llama_index等主流开源库作为知识库。文心一言插件：未来将支持通过调用文心一言插件商城中的插件（开发中）低开发门槛零代码界面：依托星河社区提供了零代码界面的智能体构建工具，通过简单的点击配置即可开发AI原生应用。简洁的代码：10行代码就可以快速开发一个智能体应用。预置资源与平台支持：大量的预置工具、平台级别的知识库，以及后续将推出的平台级别的记忆机制，都旨在加速开发过程。安装源码安装执行如下命令，使用源码安装 ERNIE Bot Agent（要求Python >= 3.8)。gitclonehttps://github.com/PaddlePaddle/ERNIE-Bot-SDK.gitcdERNIE-Bot-SDK# 首先安装Ernie Botpipinstall./erniebot# 然后安装ERNIE Bot Agentpipinstall./erniebot-agent# 安装核心模块# pip install './erniebot-agent/.[all]'   # 也可以加上[all]一次性安装所有模块，包括gradio等依赖库快速安装（暂不支持）执行如下命令，快速安装最新版本 ERNIE Bot Agent（要求Python >= 3.8)。# 安装核心模块pipinstall--upgradeerniebot-agent# 安装所有模块pipinstall--upgradeerniebot-agent[all]快速体验下面的quick_start.py示例展示了如何使用 ERNIE Bot Agent 快速构建智能体应用。importasyncioimportosfromerniebot_agent.agentsimportFunctionAgentfromerniebot_agent.chat_modelsimportERNIEBotfromerniebot_agent.toolsimportRemoteToolkitasyncdefmain():llm=ERNIEBot(model="ernie-3.5")# 初始化大语言模型tts_tool=RemoteToolkit.from_aistudio("texttospeech").get_tools()# 获取语音合成工具agent=FunctionAgent(llm=llm,tools=tts_tool)# 创建智能体，集成语言模型与工具# 与智能体进行通用对话result=awaitagent.run("你好，请自我介绍一下")print(result.text)# 模型返回类似如下结果：# 你好，我叫文心一言，是百度研发的知识增强大语言模型，能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。# 请求智能体根据输入文本，自动调用语音合成工具result=awaitagent.run("把上一轮的自我介绍转成语音")print(result.text)# 模型返回类似如下结果：# 根据你的请求，我已经将自我介绍转换为语音文件，文件名为file-local-c70878b4-a3f6-11ee-95d0-506b4b225bd6。# 你可以使用任何支持播放音频文件的设备或软件来播放这个文件。如果你需要进一步操作或有其他问题，请随时告诉我。# 将智能体输出的音频文件写入test.wav, 可以尝试播放audio_file=result.steps[-1].output_files[0]awaitaudio_file.write_contents_to("./test.wav")asyncio.run(main())运行上述代码，大家首先需要在AI Studio星河社区注册并登录账号，然后在AI Studio的访问令牌页面获取Access Token，最后执行以下命令:exportEB_AGENT_ACCESS_TOKEN=<aistudio-access-token>exportEB_AGENT_LOGGING_LEVEL=info
pythonquick_start.py详细教程教程链接。LicenseERNIE Bot Agent遵循Apache-2.0开源协议。
Package: erniepysdk
文心千帆 Python SDK本库为文心千帆 Python SDK, 非官方库 ———— 目前官方还没有 Python 的 SDK。本库代码经过 100% 测试。文心千帆目前支持：ERNIE-BotERNIE-Bot-turboBLOOMZ-7BEmbeddings安装PyPI地址：https://pypi.org/project/erniepysdk/pipinstallerniePySDK使用示例# ErnieBot 流式对话# ErnieBotTurbo 和 ErnieBot 的调用方法，甚至参数都完全相同# Bloozm7B 和 ErnieBot 的调用方法也完全相同，只是参数不同，少了 top_p 等几个参数importerniePySDKapi_key=""secret_key=""deftestErnieBotChatStream():bot=erniePySDK.ErnieBot(apiKey=api_key,secretKey=secret_key)messages=[{"role":"user","content":"请用Python写一个冒泡排序"}]chuncks=bot.chat(messages=messages,stream=True)forchunckinchuncks:print(f"Result Type:{type(chunck)}")print(chunck)if__name__=="__main__":testErnieBotChatStream()获取文心千帆 APIKEY在百度云官网进行申请：https://cloud.baidu.com/product/wenxinworkshop申请通过后创建应用：https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application获取 apikey 和 api secret其他示例ErnieBot 对话importerniePySDKapi_key=""secret_key=""deftestErnieBotChat():bot=erniePySDK.ErnieBot(apiKey=api_key,secretKey=secret_key)messages=[{"role":"user","content":"介绍一下你自己"}]r=next(bot.chat(messages=messages))print(f"Result Type:{type(r)}")print(r)testErnieBotChat()ErnieBot 对话 异步调用importerniePySDKimportasyncioapi_key=""secret_key=""asyncdeftestErnieBotAsyncChat():bot=erniePySDK.ErnieBot(apiKey=api_key,secretKey=secret_key)messages=[{"role":"user","content":"介绍一下你自己"}]r=next(bot.chat(messages=messages))print(f"Result Type:{type(r)}")print(r)asyncio.run(testErnieBotAsyncChat())ErnitBot 流式对话 异步调用importerniePySDKimportasyncioapi_key=""secret_key=""asyncdeftestErnieBotAsyncChatStream():bot=erniePySDK.ErnieBot(apiKey=api_key,secretKey=secret_key)messages=[{"role":"user","content":"Python中的生成器可以在异步程序中使用吗？"}]chuncks=bot.chat(messages=messages,stream=True)forchunckinchuncks:# print(f"Result Type: {type(chunck)}")print(chunck.get("result"),end="")asyncio.run(testErnieBotAsyncChatStream())EmbeddingV1 调用importerniePySDKapiKey=""secretKey=""deftestEmbeddingV1():bot=erniePySDK.EmbeddingV1(apiKey=api_key,secretKey=secret_key)texts=["请介绍你自己","Python中，子类继承父类后如何修改父类的属性？","什么是词向量?"]r=bot.embedding(texts=texts)print(r)testEmbeddingV1()EmbeddingV1 异步调用importerniePySDKimportasyncioapiKey=""secretKey=""asyncdeftestAsyncEmbeddingV1():bot=erniePySDK.EmbeddingV1(apiKey=api_key,secretKey=secret_key)texts=["请介绍你自己","Python中，子类继承父类后如何修改父类的属性？","什么是词向量?"]r=awaitbot.asyncEmbedding(texts=texts)print(r)asyncio.run(testAsyncEmbeddingV1())
Package: ern-reactor
ern_reactoris a Python library that allows performing arbitrary actions in reaction toErcointransfers, with live synchronization and catching up after coming back online. Licensed underApache License 2.0. Python 3.8 or newer is required.How to useSee the help forern_reactor.ErcoinReactor:importern_reactorhelp(ern_reactor.ErcoinReactor)You need to implement theget_namespaceandprocess_txmethods. To inspect the structure of the transaction dictionary which is passed toprocess_tx, seeern_reactor.TransferTx.__annotations__.A basic exampleThis scripts connects to a local Ercoin node and live prints transaction values for transfers received by an Ercoin address (Base64-encoded) specified on the command line:importasyncioimportdecimalimportsysfromern_reactorimportErcoinReactorclassDummyReactor(ErcoinReactor):defget_namespace(self):return'dummy'asyncdefprocess_tx(self,tx):amount_in_ern=decimal.Decimal(tx['value'])/10**6print(f'Received{amount_in_ern}ERN')if__name__=='__main__':reactor=DummyReactor(node='127.0.0.1',to_address=sys.argv[1],ssl=False,)try:asyncio.run(reactor.start())exceptKeyboardInterrupt:sys.exit(0)
Package: eromedownloader
eromedownloaderDownloader for erome.com hosted as python package installable via pipInstallationpipinstalleromedownloaderBasic Usagepythoneromedownloader--urlhttps://www.erome.com/a/{ALBUM_ID}Optional Arguments--path: str, path/to/save/dir--override: bool, whether to override album if already exists instead of downloading it under an incremented name version;Default=False--concurrent-requests-max: int, max number of requests to be sent; sending too many requests at once may comprise the risk of getting your IP banned by erome;Default=4--ignore-images: bool;Default=False--ignore-videos: bool;Default=False