Saravanan666/pypi-org huggingface dataset:
Package: ecstatic
Slightly NIH Flask-based app to serve static content. It tries to capture 80%
of the use-cases that are normally handled by the likes of nginx and Apache,
only much slower =).Other packages that do similar, but not quite the same things:https://pypi.python.org/pypi/Flask-Ecstatic(sorry about the name!)ConfigurationEcstatic has a single configuration file whose location is given via an
environment variable “ECSTATIC_EXPORTS”. The file is parsed using Python3’sconfigparsermodule, with each section being processed from top to bottom.Whenever a request comes in, a section is checked for whether or not it
matches. If a match is found, no further sections are examined and the
configuration in said section is used to serve the request.A section matches a request if itHas amatchkey with a regular expression that matches the request’s
path orHas arootsection with no match present.Any other section is ignored.match-SectionsAny section that contains amatch-key must also contain anfspath-key.
If the URL path matches the expression given,fspathis interpolated as a
format string, with positional arguments from the expression (missing groups
are empty strings instead ofNone).The section must still contain aroot-entry, also a format string, which is
used to jail paths.root-SectionsAny section containing just aroot-entry will simply serve content from the
given root path, mapping 1:1 onto URLs.ExamplesA simple configuration that serves content from userspublic_html-directories (which are assumed to all be inside/home) and/var/wwwotherwise:[homes]# exposes /home/bob/public_html/ on http://example.org/~bob/match=^~([a-zA-Z0-9]+)(/.*)?$fspath=/home/{0}/public_html{1}root=/home/{0}dirindex=on[www]root=/var/www
Package: ectoken
===============================Python implementation of EdgeCast Token===============================Python implementation of EdgeCast Token (ectoken_generate).* Free software: BSD licenseUsage-----```import ectokenkey = 'XXXXXXXXXXXXXX'url = 'http://my.edgesuite.net/path/to/my/file.txt'print ectoken.ectoken_generate(key, url)```History-------0.4 (2015-03-03)++++++++++++++++++* First release on PyPI.
Package: ectool
移芯工具箱支持移芯方案的刷机, 解包, windows/linux/macos 可用当前支持EC618系列, 例如Air780E/Air700E/Air600E/Air780EG等模块本库可支持被引用, eccli本身就是调用实例.用法先安装ectool, 在命令行或控制台执行# 清华镜像pip3install-U-ihttps://pypi.tuna.tsinghua.edu.cn/simpleectool# 若安装失败, 可尝试以下命令, 从pypi直接进行安装pip3install-Uectool刷机(当前仅USB刷机), 支持binpkg和soc文件ectoolburn-fexample.binpkg# 启动后, 按住BOOT键, 复位模块, 或模块开机更多参数执行ectool -h获取说明TODO ListEC618使用USB刷机binpkg解包兼容Linux下刷机兼容Mac下刷机支持只刷AP或CP支持跳过AgentBoot支持擦除指定区域的数据SoC日志解析(简易)支持从http加载固件文件进行下载EC618使用物理UART刷机支持刷LuatOS的script.bin完整的注释SoC日志解析(完整)binpkg打包Linux刷机过程展示参考链接流程参考PSU的某种设备的文档beanio做的逆向版本beanio-ec618-downloader开源协议MIT
Package: ecubevis
Welcome to the repository of ecubevisecubevis: Earth CUBE VISualization with Python. Intended for the interactive exploration of n-dimensional (2D, 3D, 4D or 5D spatio-temporal) arrays on Jupyterlab. Supports bothxarray.Dataset/DataArray(with metadata) ornumpy.ndarrayobjects.How to installInstallecubevisfrom pypi:pip install ecubevisIf installingcartopywith pip is not working, use conda:conda install cartopyIf cartopy kills your Jupyter notebook kernel try this:pip install shapely --upgrade --force-reinstall --no-binary shapelyHow to useImport the library:importecubevisasecvThe main function inecubevisisecv.plot(). In interactive mode, the plot comes with sliders (thanks tohvplot/holoviews) allowing easy exploration of multi-dimensional data as 2D arrays across the time and additional dimensions. Under the hood,ecv.plot()calls one of the following functions depending on the data type:ecv.plot_ndarray(): For plotting an in-memorynumpy.ndarrayobject with 2, 3, 4 or 5 dimensions (ndarrays do not carry metadata so the dimensions are given with thedimensionsargument). The function can take a tuple of 2D ndarrays, even with different grid/image size.ecv.plot_dataset(): For plotting an in-memoryxr.Datasetorxr.DataArrayobjects with 2, 3, or 4 dimensions. The dimensions expected are [lat, lon] for 2D arrays, [time, lat, lon] for 3D arrays or [time, level, lat, lon] for 4D arrays.Examplesecubeviswill allow you to create:InteractiveStaticplots of in-memory 2D, 3D and 4Dxr.Datasetorxr.DataArrayobjects:mosaics of in-memory 3D and 4Dxr.Datasetorxr.DataArrayobjects:plots of in-memory 2D, 3D and 4Dnumpy.ndarrayobjects (composition thanks toholoviews):plots of in-memory 2D, 3D and 4Dnumpy.ndarrayobjects:plots of in-memoryxr.Datasetorxr.DataArraywhile sub-setting across dimensions:plots of a tuple of in-memory 2Dnumpy.ndarrayobjects:
Package: ecutilities
ecutilitiesInstallation:PyPipip install ecutilitiesGitHubTwo options to get versions which are not yet released on PyPi:clone the githubrepoand
install it in edit mode from within the cloned repo:pip install -e .install with pip from the github repo directly for hosted virtual
machines:pip install git+https://github.com/vtecftwy/ecutils.git@master
pip install git+https://github.com/vtecftwy/ecutils.git@developModules:General use:coreipythonplottingData Science and Machine learning:eda_stats_utilsmlImagesimage_utilsDevelopmentdev_utils
Package: ecutils
Elliptic Curve Utils (ecutils)Elliptic Curve Utils, orecutils, is a Python package that provides utilities for working with elliptic curves, particularly in the context of cryptography. It includes functionality for operations like point addition and scalar multiplication on curves, as well as higher-level protocols like key exchange and digital signatures.FeaturesImplements common elliptic curve operations such as point addition and multiplication.Provides classes for encoding/decoding textual messages to and from elliptic curve points (e.g., Koblitz encoding).Supports several standardized elliptic curves including secp192k1, secp256r1, and secp521r1.Includes an implementation of the Elliptic Curve Digital Signature Algorithm (ECDSA) for signing messages and verifying signatures.Features key exchange protocols like Diffie-Hellman and Massey-Omura over elliptic curves.InstallationYou can install theecutilspackage usingpip:pipinstallecutilsUsageEncoding and Decoding Messages with Koblitzfromecutils.algorithmsimportKoblitz# Initialize Koblitz with a specific curvekoblitz=Koblitz(curve_name="secp256k1")# Encode a message to a curve pointpoint,j=koblitz.encode("Hello, World!")# Decode the curve point back to a messagedecoded_message=Koblitz.decode(point,j)Digital Signatures with ECDSAfromecutils.algorithmsimportDigitalSignature# Create a DigitalSignature instance with your private keyds=DigitalSignature(private_key=123456)# Hash of your messagemessage_hash=hash('your message')# Generate signaturer,s=ds.generate_signature(message_hash)# Verify signature (typically on the receiver's side)is_valid=ds.verify_signature(ds.public_key,message_hash,r,s)Diffie-Hellman Key Exchangefromecutils.protocolsimportDiffieHellman# Alice's sidealice=DiffieHellman(private_key=12345)# Bob's sidebob=DiffieHellman(private_key=67890)# Alice computes her shared secret with Bob's public keyalice_shared_secret=alice.compute_shared_secret(bob.public_key)# Bob computes his shared secret with Alice's public keybob_shared_secret=bob.compute_shared_secret(alice.public_key)# alice_shared_secret should be equal to bob_shared_secretDocumentationFor more in-depth use and examples, check out theofficial documentation.SupportFor issues, questions, or contributions, please refer to the project'sGitHub repository.LicenseThis project is licensed under theMIT License.Don't forget to give this project a star if you find it useful! 🌟
Package: ecws
电力领域中文分词模型ecws　是面向电力领域的基础中文分词模型组件，目标是打造电力领域的自然语言处理基础能力安装指南ecws 依赖以下包:torch==1.5.1allennlp==1.0.0版本号R3.0.5模型命名NLP-ECWS-R3.0.5安装第一步，安装 ecws使用 pip 安装pipinstallecws或从源代码安装gitclonehttps://github.com/rises-tech/ecws.gitcdNLP-ECWS
pipinstall-e.下载ecws.model文件Model NameDownload Linkecws.v3.modelBaiduPan提取码：ecwspython引用方式：fromecws.segmentimportSegmentermodel_path='ecws.model'predict=Segmenter(model_path)d=predict.seg(sent)接口demo界面http://120.27.25.150:8082/web api 调用方式defwebservice_ecws(sentence):data={'sent':sentence}url='http://120.27.25.150:8082/predict'r=requests.post(url,json=data)data=json.loads(r.text)seg=data['spans']returnseg其中返回的结果是一个字典，字段'sent'中包含分词结果。电力自然语言处理演示平台http://demo.rises.tech开发者@ 张强<<alxor@live.cn>>
@ 宋博川<<abc_hhhh@163.com>>
Package: ecxclient
This project aims to build a Python client for Catalogic Software’sECXproduct.This repo holds two components.An SDK that can be used by anyone interested in integrating ECX
operations in their workflow.A command line utility with which ECX operations can be performed.Installation$ pip install ecxclientUsage$ ecxcli --help

# This connects to ECX on localhost.
$ ecxcli --user admin --passwd <PASSWORD> job list

# To connect to a different host. Default user is "admin".
$ ecxcli --url https://1.2.3.4:8443 --passwd <PASSWORD> job listNotesAfter a successful login, the command “remembers” the login session
so there is no need to pass user name and password with every
run.Known IssuesWhen “https” URL is used, there are some warnings displayed on the
console. We need to find a way to get rid of them.
Package: ecys
Ecys is a simple realization of Entity Components SystemEcys is an MIT licensed Entity Component System (ECS).
The design is based onanaxrealization of ECS.1) CompatibilityEsyc is a Python 3 library only. Specifically, all currently supported versions of Python 3.2) InstallationYou can install ecys usingpip:pip install ecys3) StructureWorldA World is your main working object to interact with ecys.
After creating a World object, you’ll use that object to crate Entities
from your Component objects. A World is assigned all of your System
instances. A World allows you to update all your Systems using call per frame.
You can create or delete Entities, add or remove Systems while your
application is running.EntityEntity is a simple container for Components. You can add or remove
Components from your Entity.ComponentsYou should define your Component classes. They should not contain
any logic. Components might have initialization code, but no
updating state logic. You can useecys.Componentto indicate your
class as Component, but it’s not obligatory.Example of simple Velocity component:from dataclasses import dataclass

@dataclass
class Velocity(ecys.Component):
    x: float
    y: floatSystemsSystems are where all processing logic is executed. All Systems must
inherit from theecys.Systemclass, and have a method calledupdate.
You should add your System to the World instance to using.
You can define your System classes withecys.requiresorecys.excludesdecorators. Anentitiesproperty returns
tuple of Entities with (or without) Components specified in decorator
parameters. If you have not defined a decorator anentitiesreturns
all entities in your World.A simple MovementSystem:@ecys.requires(Position, Velocity)
class MovementSystem(ecys.System):

    def update(self):
        for entity in self.entities:
            position = entity.get_component(Position)
            velocity = entity.get_component(Velocity)
            position.x += velocity.x
            position.y += velocity.y4) Basic usageThe first step after importing ecys is to create a World instance:world = ecys.World()Create some System instances and add to the World. You can specify
an optional updating priority (higher number = faster). By default
priority is 0:movement_system = MovementSystem()
render_system = RenderSystem()
world.add_system(movement_system, 1)
world.add_system(render_system)
# . . .
world.add_system(AnotherOneSystem())Create Entities:player = world.create_entity(Position(0, 0), Velocity(1, 2))
# . . .
player.add_component(AnotherOneComponent(*args))Executing all Systems is done with a single call toworld.update. This
will call the update methods on all added Systems, in order of their priority:world.update()You can pass any args you need toworld.update, but you must also make sure to receive
them properly in theupdatemethods of your Systems. For example, if you pass a delta time
argument asworld.update(delta_time), your Systems’supdatemethods should all receive it as:def process(self, delta_time):
Package: ed25519
Python bindings to the Ed25519 public-key signature system.This offers a comfortable python interface to a C implementation of the
Ed25519 public-key signature system (http://ed25519.cr.yp.to/), using the
portable ‘ref’ code from the ‘SUPERCOP’ benchmarking suite.This system provides high (128-bit) security, short (32-byte) keys, short
(64-byte) signatures, and fast (2-6ms) operation. Please see the README for
more details.## Not Recommended For New Applications: Use pynacl InsteadFor new applications, I recommend you use
[pynacl](https://github.com/pyca/pynacl) instead of this repository.PyNaClis larger and takes longer to build (it contains the complete
NaCl/libsodium library, not just the ed25519 portion), but it is
well-maintained by the diligent and conscientious PyCA team, whereas I’ve
allowed this repository to languish.PyNaClis also about 10-20 times
faster. A guide for migration fronpython-ed25519toPyNaClis included
below.
Package: ed25519-blake2b
A fork of python-ed25519 that uses BLAKE2b instead of SHA512 as a hash function
as used in the NANO cryptocurrency.
Original code written by @warner on GitHub:
github.com/warner/python-ed25519Python bindings to the Ed25519 public-key signature system.This offers a comfortable python interface to a C implementation of the
Ed25519 public-key signature system (http://ed25519.cr.yp.to/), using the
portable ‘ref’ code from the ‘SUPERCOP’ benchmarking suite.This system provides high (128-bit) security, short (32-byte) keys, short
(64-byte) signatures, and fast (2-6ms) operation. Please see the README for
more details.
Package: ed25519ll
About Ed25519Ed25519 is a public-key signature system with several attractive features
including:Fast single-signature verification.Very fast signing.Fast key generation.High security level.Small signatures. Signatures fit into 64 bytes.Small keys. Public keys consume only 32 bytes.This text abridged fromhttp://ed25519.cr.yp.to/.About ed25519lled25519ll is a low-level wrapper for the Ed25519 public key signature
system. It uses Extension() to compile a shared library that is not a
Python extension module, and then uses ctypes to talk to the library. With
luck it will only be necessary to compile ed25519ll once for each
platform, reusing its shared library across Python versions.This wrapper currently exposes the supercop-ref10 implementation of
Ed25519, on my 2.6GHz Athlon achieving about 7200 signatures/second/core
and 2900 verifications/second/core including the wrapper overhead.This wrapper also contains a reasonably performat pure-Python
fallback. Unlike the reference implementation, the Python implementation
does not contain protection against timing attacks.Example:import ed25519ll
msg = b"The rain in Spain stays mainly on the plain"
kp = ed25519ll.crypto_sign_keypair()
signed = ed25519ll.crypto_sign(msg, kp.sk)
verified = ed25519ll.crypto_sign_open(signed, kp.vk)
assert verified == msg  # but ValueError is raised for bad signaturesAPIed25519ll exposes the supercop-ref10 API rather directly. All messages and keys
are binary strings (bytes() or Python 2 str()). Signed messages consist of the
64 signature bytes concatenated with the message.Keypair()is a named tuple(vk, sk)of the verifying key (32 bytes) and
the signing key (64 bytes). The second half of the signing key is a copy of the
verifying key.crypto_sign_keypair()returns a newKeypair().os.urandom()is used
as the random seed. This operation is about as fast as signing.crypto_sign(msg, sk)takes a message (any binary string) and a 64-byte
signing key (from crypto_sign_keypair()) and returns a signed message.crypto_sign_open(signed, vk)takes a signed message (64 byte signature +
message) and the corresponding 32-byte verifying key and returns a copy of the
message without the attached signature.ValueErroris raised for invalid
signatures.0.6Include pure-Python fallback implementation0.5Switch to ctypes to avoid parser overhead for such a trivial library0.4Switch away from ffi.verify() again0.3Switch to supercop-ref10Switch to ffi.verify()Update to work with cffi 0.3Update to work with Python 3.30.2100% test coverageBasic documentation0.1Initial release
Package: ed25519sha3
Python bindings to the Ed25519 public-key signature system.This offers a comfortable python interface to a C implementation of the
Ed25519 public-key signature system (http://ed25519.cr.yp.to/), using the
portable ‘ref’ code from the ‘SUPERCOP’ benchmarking suite.This system provides high (128-bit) security, short (32-byte) keys, short
(64-byte) signatures, and fast (2-6ms) operation. Please see the README for
more details.
Package: eda
SynopsisThe Pythonedamodule provides a framework to create Python applications
in Event-Driven Architectures (EDAs).FeaturesThe module provides the following major features:A syntax to declaratively specify event types and their structure.Local implementations of an enterprise message bus, using threads
(for single-process architectures) or processes.An interface specification of the enterprise message bus; allowing
additional, more mature implementations (using for example, Apache
Apollo).A framework to quickly prototype and deploy services.InstallationTo installeda, run the following command in your terminal:$pipinstalledaAlternatively, you may clone the GitHub repository to install the latest
development branch. This method provides the following options:Runpython3 setup.py install.Runmake links. This will create symbolic links in the systems’ Python library
directory. Provided as a conveniance when developing the module in cooperation with
other packages or applications.
Package: eda5grpc
edagames-grpgRPC interface for edagames platform-game communication## CompilingTo compile protobuf definition into Python files install grpcio-tools and executepython -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. ./eda_games.proto## ExamplesExamples for simple client and server are located in theexamples folderTo run them each example use:Client:python -m examples.clientServer:python -m examples.server
Package: edaac
EDA Analytics CentralThe ProblemWhile there is anartto chip design, measuring design processes can result in precious data that help advancing thescienceof chip design.
System-on-Chip (SoC) design flows yield a huge amount of data that can be useful in optimizing the design process and achieving maximum productivity.
However, there currently exists no solution that makes it easy to collect, store and analyze data coming out of a SoC design flow.The SolutionEDA Analytics Central (EDAAC)addresses this problem by building on top of a previously well-studied data collection specification, called METRICS [1, 2].
The goal of EDAAC is to make it painless to perform the following tasks:Data Collection:Passive collection (aka: Log file mining): using scripts (shell tools + python) to extract metrics from log files after a flow finishes.Active Collection (i.e. Data model extraction): using middle-layer functions that extract from data models (i.e. OpenDB) during a flow run.Data Storage: storing and indexing data in a persistent structural database that can support data analytics tasks.Data Querying:Offline usage: the flow has run and ended, metrics are stored (either passively or actively). This supports ML around tools.Online usage: the flow is currently running and a tool wants to take a decision based on a collected metric during the flow run. This supports ML in tools.Getting StartedInstall$ pip install edaacDocumentationhttps://edaac.readthedocs.io/en/latest/LicenseBSD 3-Clause LicenseCreditsIcon made bymynamepongfromwww.flaticon.comReferences[1] Fenstermaker, Stephen, et al. "METRICS: a system architecture for design process optimization." Proceedings of the 37th Annual Design Automation Conference. ACM, 2000.[2] Kahng, Andrew B., and Stefanus Mantik. "A system for automatic recording and prediction of design quality metrics." Proceedings of the IEEE 2001. 2nd International Symposium on Quality Electronic Design. IEEE, 2001.
Package: eda-and-beyond
EDA and Beyond - Python library for automating common procedures in machine learningContributors:Freda Xin,Mahdi Shadkam-FarrokhiProject DescriptionThe package provides a collection of automation tools for some common procedures
in machine learning. The current version aims to streamline the EDA and modeling
process forScikit-Learn models.The package consists of two modules:eda_tools:
provides functions to automate common procedures in EDA, model
preparation, and data visualization etc.modeling_tools:
provides a class object that includes methods to streamline the modeling process for Scikit-Learn models.This is an open-source project. Contributors are welcome. :)Installationpip install eda_and_beyondMore ResourcesBlog post on using Python functions in EDABlog post on using Python classes in modeling(coming soon)
Package: eda-and-clean
--Project DescriptionThe project provides a collection of automation tools for commonly used EDA and cleaning techniques.The package consists of three modules,EDA - Contains a class which provides automation for detecting datat types, listing null values, identifying redundant entries, basic data analysis among othersclean - Contains a class which provides options for the user to perform cleaning tasks such as cleaning string columns, downcasting data types, assigning proper data types, making certain entries as na as necessary, dropping duplicates. More importantly it also tracks all the changes made in a easy to read format and the rows and columns it impacted so that the user can easily keep track of changes.chart - Contains functions for plotting purposes with embedded formatting.This is an open-source project. Contributors are welcome. :)
Package: edacious
Edacious an Event Derive Architecture frameworkImplementing an EDA usually requires a queue mechanism. Currently support Redis streams and Amazon Web Services SQS.Event must be a dict that contain data to be processed.
Every event must have an event type (str) attribute, reserve key isevent-type.To process an event the event type has to be associated to one or more event handlers.Event handler is a function that receive an event (dict) and process it, here is an example for running event listener based on Amazon Web Services SQS.from edacious.sqs import EventListener

SQS_URL = 'https://sqs.my-region.amazonaws.com/123456789012/my-app-sqs'


@event_handler(event_type='hello-world')
def my_handler(event: dict):
    print(event)


if __name__ == '__main__':

listener = EventListener(sqs_url=SQS_URL, visibility_timeout=60, max_messages_to_fetch=10)
listener.set_seconds_to_wait(seconds=2.5)
listener.run()