Saravanan666/pypi-org huggingface dataset:
Package: edgegraph
EdgeGraphEdgeGraph is an object-oriented approach to network graphs.  It provides
classes to inherit from in other applications / modules, and provides
out-of-the-box operations for these classes and any subclasses of.The intent of EdgeGraph is to allow applications to model related data with a
method closer to reality, without having to implement a custom graph module.
It provides facilities to this end, such as the base classes to allow linking
and the functions to perform it.The base classes are also usable directly, should you wish to test-drive this
idea or study abstract graphs.PrealphaAt this time, this project is extremely young.  Persemantic versioning,
it is in version 0.  This means that the API may be changed at any time,
without warning.Planned features include:Single base class for all objects, with custom data supportVertex-edge graphs"Universe" class to contain graphs as a single unitClass-based edges, can associate arbitrary data with edgesAutomatic edge update propagation to necessary endpointsAdjacency list / matrix build-a-graphBuild-an-adjlist / build-an-adjmat from graphsBreadth-first search and traversalDepth-first search and traversalTopological sortingStrongly connected component detectionUniverse island detectionShortest path detectionGraph drawing generation via PlantUMLFormal automata modelling (DFA, NFA, etc)Operation flow graph modelling (nodes as operations instead of states)"Functional graphs" -- attach executable code to nodes and run a graph as
a programObject serialization, save-to- and load-from-fileThese features, as with the API, may be changed or dropped at any time without
warning.  I do have a day job, after all :)Sphinx documentation and full Pytest-driven unit testing coverage is expected
to match the progress of the code.
Package: edgehub
edgehub一款灵活高效的，跨进程分布式边缘计算引擎。安装方式pip3 install edgehub使用示例示例1该示例由一个Master节点和两个Node节点组成。Master负责消息传递，不负责运算。两个Node，一个Node节点负责实时读入摄像头视频流，另一个Node节点负责展示前一个Node读到的视频流。本示例需要安装python-opencv: pip3 install opencv-pythonmaster.pyfromedgehubimportMasterif__name__=='__main__':SERVER_IP='127.0.0.1'SERVER_PROT=9010m=Master("master",address=(SERVER_IP,SERVER_PROT),authkey=b'z',log_level="DEBUG")server=m.get_server()server.serve_forever()node_cam_read.pyfromedgehubimportNodeimportcv2classCameraNode(Node):stream=Nodecamera_url=1defbefore_run(self):self.register_queue("cam")self.stream=cv2.VideoCapture(self.camera_url)defon_queue_process(self,queue_name):(grabbed,frame)=self.stream.read()self.put(frame,queue_name)if__name__=='__main__':SERVER_IP='127.0.0.1'SERVER_PROT=9010n=CameraNode("cap_put",address=(SERVER_IP,SERVER_PROT),authkey=b'z')n.run()node_cam_show.pyfromedgehubimportNodeimportcv2classCamGetNode(Node):defbefore_run(self):self.register_queue("cam")defon_queue_process(self,queue_name):item=self.get(queue_name)cv2.imshow("queue_name",item)key=cv2.waitKey(1)&0xFFifkey==ord("q"):raiseStopIteration()# 为了确保队列不积压 导致延迟递增  每次执行完后清空当前队列，这样每次处理时就会取到最新图片self.clear(queue_name)if__name__=='__main__':SERVER_IP='127.0.0.1'SERVER_PROT=9010n=CamGetNode(name="cam_get",address=(SERVER_IP,SERVER_PROT),authkey=b'z')n.run()
Package: edgeimpulse
Edge Impulse SDKThe official Python SDK for Edge Impulse is designed to help machine learning practitioners build and deploy models for embedded hardware and edge AI applications.Profile your model to estimate RAM, ROM, and inference speedConvert your model to C++ to deploy on edge hardwareInteract with Edge Impulse projects to collect data, train models, and deploy them to edge devicesSign up for a free account →List of versions and changes can be foundin this changelog.Getting StartedInstall the Edge Impulse Python SDK:pipinstalledgeimpulseEstimate RAM, ROM, and inference speed for a variety of hardware platforms:importedgeimpulseasei# Change to an API key from your Edge Impulse projectei.API_KEY="your-api-key"# Print inference estimatesresult=ei.model.profile(model="path/to/model")result.summary()To learn about the full functionality, see the resources below.ResourcesOverview and getting startedTutorial demonstrating how to profile and deploy a modelAPI reference guide
Package: edgelist-mapper
edgelist-mapper📊 Maps nodes and edges of a multi-relational graph to integerSynopsisedgelist-mapper is a simple tool that reads an edge-list file representing a graph and maps each node and relation to integer.
The mapping assigned is such that entities and relations that appear more frequently in the graph are mapped to smaller numerical values.This tool is particularly useful to pre-process some of the publicly available knowledge graph datasets that are often used for the machine learning task ofrelation prediction.Input formatThe tool takes as input a file (edgelist.tsv) that represents a graph as tab-separated triples of the form(head, relation, tail)and generates three new files, namelymapped_edgelist.tsv,entities_map.tsv, andrelations_map.tsv.san_marino	locatedin	europe
belgium	locatedin	europe
russia	locatedin	europe
monaco	locatedin	europe
croatia	locatedin	europe
poland	locatedin	europeExample content of theedgelist.tsvfile.0	europe
1	san_marino
2	russia
3	poland
4	monaco
5	croatia
6	belgiumContent of theentities_map.tsvgenerated from theedgelist.tsvfile.0	locatedinContent of therelations_map.tsvgenerated from theedgelist.tsvfile.1	0	0
6	0	0
2	0	0
4	0	0
5	0	0
3	0	0Content of themapped_edgelist.tsvgenerated from theedgelist.tsvfile.CLI UsageThe CLI takes the following positional arguments:edgelist    Path of the edgelist file
  output      Path of the output directoryExample usage:pipinstalledgelist-mapper
python-medgelist_mapper.bin.run\edgelist.tsv\.NB: You need Python 3 to run the CLI.ShowcaseThis tool has been used to createthis collection of datasets.AuthorsSimone Primarosa-simonepriSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the MIT License - see thelicensefile for details.
Package: edgeml
Edge Machine LearningCopyright (c) Microsoft CorporationAll rights reserved.MIT LicensePermission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the “”Software””), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial
portions of the Software.THE SOFTWARE IS PROVIDEDAS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: edgeml-pytorch
Edge Machine Learning: Pytorch LibraryThis package includes PyTorch implementations of following algorithms and training
techniques developed as part of EdgeML. The PyTorch graphs for the forward/backward
pass of these algorithms are packaged asedgeml_pytorch.graphand the trainers
for these algorithms are inedgeml_pytorch.trainer.Bonsai:edgeml_pytorch.graph.bonsaiimplements
the Bonsai prediction graph. The three-phase training routine for Bonsai is decoupled
from the forward graph to facilitate a plug and play behaviour wherein Bonsai can be
combined with or used as a final layer classifier for other architectures (RNNs, CNNs).
Seeedgeml_pytorch.trainer.bonsaiTrainerfor 3-phase training.ProtoNN:edgeml_pytorch.graph.protoNNimplements the
ProtoNN prediction functions. The training routine for ProtoNN is decoupled from the forward
graph to facilitate a plug and play behaviour wherein ProtoNN can be combined with or used
as a final layer classifier for other architectures (RNNs, CNNs). The training routine is
implemented inedgeml_pytorch.trainer.protoNNTrainer.FastRNN & FastGRNN:edgeml_pytorch.graph.rnnprovides
various RNN cells --- including new cellsFastRNNCellandFastGRNNCellas well asUGRNNCell,GRUCell, andLSTMCell--- with features like low-rank parameterisation
of weight matrices and custom non-linearities. Akin to Bonsai and ProtoNN, the three-phase
training routine for FastRNN and FastGRNN is decoupled from the custom cells to enable plug and
play behaviour of the custom RNN cells in other architectures (NMT, Encoder-Decoder etc.).
Additionally, numerically equivalent CUDA-based implementationsFastRNNCUDACellandFastGRNNCUDACellare provided for faster training.edgeml_pytorch.graph.rnn.edgeml_pytorch.graph.rnn.Fast(G)RNN(CUDA)provides unrolled RNNs equivalent tonn.LSTMandnn.GRU.edgeml_pytorch.trainer.fastmodelpresents a sample multi-layer RNN + multi-class classifier model.S-RNN:edgeml_pytorch.graph.rnn.SRNN2implements a
2 layer SRNN network which can be instantied with a choice of RNN cell. The training
routine for SRNN is inedgeml_pytorch.trainer.srnnTrainer.Usage directions and examples notebooks for this package are providedhere.InstallationIt is highly recommended that EdgeML be installed in a virtual environment.
Please create a new virtual environment using your environment manager
(virtualenvorAnaconda).
Make sure the new environment is active before running the below mentioned commands.Use pip to install requirements before installing theedgeml_pytorchlibrary.
Details for cpu based installation and gpu based installation provided below.CPUpip install -r requirements-cpu.txt
pip install -e .Tested on Python3.6 with >= PyTorch 1.1.0.GPUInstall appropriate CUDA and cuDNN [Tested with >= CUDA 8.1 and cuDNN >= 6.1]pip install -r requirements-gpu.txt
pip install -e .Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the MIT license.
Package: edgeofpy
Package for assessing the distance to criticality in brain dynamics.FeaturesComing soon.InstallationInstall edgeofpy by running:pip3 install edgeofpyDocumentationComing soon.Change LogComing soon.RequirementsPython 3.7 or laternumpyscipymatplotlibpowerlawneurokit2LicenseThe project is licensed under the Apache 2.0 license.
Package: edgepi-rpc-client
EdgePi RPC ClientThe RPC client exposes functionality of the EdgePi Python SDK to be used over either a network connection or on local sockets, allowing for potential remote control of the EdgePi.Since the client directly mirrors the SDK, you can take advantage of the user-friendly SDK functionality with the flexibility of different connection protocols depending on your specific use case.You can learn more about the Python SDKhere.Using the RPC ClientInstall the RPC client through the terminal:$ python3 -m pip install edgepi-rpc-clientOnce installed, you can control the modules of the EdgePi directly through the SDK's wide functionality.For example, from a remote connection with addresslocalhostand port5555, initialize a client module as:fromedgepi_rpc_client.services.adc.client_adc_serviceimportClientAdcServicefromedgepi_rpc_client.services.adc.adc_pb_enumsimportADCChannel,ConvMode# initialize ADC Clientadc_client=ClientAdcService('tcp://localhost:5555')# configure ADC to sample input pin 4 (the input pins are 0-indexed)adc_client.set_config(adc_1_analog_in=ADCChannel.AIN3,conversion_mode=ConvMode.CONTINUOUS)# send command to start automatic conversionsadc_client.start_conversions()# perform 10 voltage readsfor_inrange(10):out=adc_client.read_voltage()print(out)# stop automatic conversionsadc_client.stop_conversions()Once the client is initialized you can control the EdgePi exactly as you would through the SDK.For details about available modules visit the SDK GitHub repository linked above.
Package: edgepi-rpc-protobuf
EdgePi RPC Protobuf Python LibraryEdgePi RPC Protobuf package for installation in a Python environment.Recompile Python-generated code for this package:protoc -I=. --experimental_allow_proto3_optional --python_out=./python_rpc/protobufs <filename.proto>Importing python generated codeInstall this package as:pip install edgepi-rpc-protobufImport as:from python_rpc.protobufs import <>
Package: edge-pptx
edge_pdf 使用说明概述edge_pdf 是一个用于生成 PowerPoint 文件的 Python 模块。它提供了一系列方法用于插入表格、文本、图片和图表等内容，并可以保存生成的 PPT 文件。使用方法1. 导入模块及类fromedge_pdfimportPlaceholderComponent,PPTTable,PPTGenerator2. 创建 PPTGenerator 实例ppt=PPTGenerator()或者使用现有的模板文件创建实例：template_ppt="template.pptx"ppt=PPTGenerator(template_ppt)3. 插入内容3.1 插入表格data=your_data_frameslide_index=0# 第几张幻灯片placeholder_index=0# 占位符索引ppt.insert_table(data,slide_index,placeholder_index)3.2 插入文本content_text="Your text content"slide_index=0# 第几张幻灯片placeholder_index=1# 占位符索引ppt.insert_text(content_text,slide_index,placeholder_index)3.3 插入图片image_file_path="path/to/your/image.jpg"slide_index=0# 第几张幻灯片placeholder_index=2# 占位符索引ppt.insert_picture(image_file_path,slide_index,placeholder_index)或者从 URL 插入图片：image_url="http://example.com/image.jpg"slide_index=0# 第几张幻灯片placeholder_index=2# 占位符索引ppt.insert_picture(image_url,slide_index,placeholder_index)3.4 插入图表chart_type=XL_CHART_TYPE.LINE# 图表类型，参考 pptx.enum.chart.XL_CHART_TYPEchart_data=your_chart_dataslide_index=0# 第几张幻灯片placeholder_index=3# 占位符索引ppt.insert_chart(chart_type,chart_data,slide_index,placeholder_index)4. 保存 PPT 文件output_file="output.pptx"ppt.save_ppt(output_file)注意事项插入内容时的幻灯片索引和占位符索引都是从0开始的。插入表格时，数据应为 Pandas DataFrame 对象。以上就是 PPTGenerator 类的使用说明。希望对您有所帮助！如有任何问题，请随时向我提问。
Package: edgeprediction
Documentation for the EdgePrediction libraryThis repository contains a Python implementation of the knowledge graph edge prediction algorithm described in Bean et al. 2017, and the input drug knowledge graph used in that paper. The algorithm is a general binary classifier that leans a model to predict new members of a given class within the training data.InstallThe package is available through pip:pip install edgepredictionContents:IntroductionDependenciesDependencies listUsage exampleInitial setupInput data formatLoad dataPrepare to run prediction algorithmRun prediction algorithmEdgePrediction class documentationObjective class documentationUtils class documentationContributingAcknowledgementsThis work is funded by the National Institute for Health Research (NIHR) Biomedical Research Centre at South London and Maudsley NHS Foundation Trust and King’s College London.The publicly available drug data as used in Bean et al. 2017 was collected from DrugBank (www.drugbank.ca) and SIDER (http://sideeffects.embl.de).Documentation and testingDocumentation is built with sphinx from docs_templates with sphinx>=v3.4.3sphinx-build -M markdown ./ ../docsTesting with pytestpython -m pytest tests
Package: edgeql_qb
EdgeQL Query BuilderQuery builder for EdgeDBDescriptionThis project is currently in pre-alpha status, meaning that it is not yet production-ready and may be buggy and unstable.Please note that this project is not affiliated with the official developers of EdgeDB.Additionally, it is important to know that this project only supports a small part of the EdgeDB syntax.The library does not include any code for connecting to the database or executing queries.It also does not provide database introspection, so it will not check for typos in column names. What you write is what you get.Python version 3.10 or higher is required to use this library, and there are currently no plans for backporting to earlier versions.There are no external dependencies, including EdgeDB itself.Usage examplesMany examples of queries are given in thedocumentationdirectory.fromedgeql_qbimportEdgeDBModelfromedgeql_qb.typesimportint16fromedgedb.blocking_clientimportcreate_clientclient=create_client()Movie=EdgeDBModel('Movie')Person=EdgeDBModel('Person')insert=Movie.insert.values(title='Blade Runner 2049',year=int16(2017),director=(Person.select().where(Person.c.id==director_id).limit1),actors=Person.insert.values(first_name='Harrison',last_name='Ford',),).build()select=(Movie.select(Movie.c.title,Movie.c.year,Movie.c.director(Movie.c.director.first_name,Movie.c.director.last_name,),Movie.c.actors(Movie.c.actors.first_name,Movie.c.actors.last_name,),).where(Movie.c.title=='Blade Runner 2049').build())delete=Movie.delete.where(Movie.c.title=='Blade Runner 2049').build()decade=(Movie.c.year//10).label('decade')group=Movie.group().using(decade).by(decade).build()client.query(insert.query,**insert.context)result=client.query(select.query,**select.context)movies_by_decade=client.query(group.query,**group.context)client.query(delete.query,**delete.context)StatusQueries:selectnested shapesfilters for nested shapesorder by for nested shapeslimit/offset for nested shapesaggregations for nested shapesfunction callscomputed fieldsfiltersfilter by nested pathslimit & offsetorder bybacklinkssubqueriespolymorphic fieldslink properties(@notation)detachedgroupcolumnsusingbyfunction callsupdatefunction callsnested queriesdeletedelete without filtersfunction callslimit & offsetorder byinsertnested insertsconditional insertsidempotent insertselect-or-insertfunction callspositional argumentskeyword argumentswith blockwith literalwith subquerywith module + closurewith x := subquery select xwith x := subquery group xwith x := subquery update xwith x := Type.columnif statementsglobalsfor statementsunion statementsqueries without models, like select [1,2,3]Types:type castscal::date_durationcal::relative_durationstd::arraystd::jsonstd::rangestd::setstd::tuplecal::local_datecal::local_datecal::local_datetimecal::local_timestd::bigintstd::boolstd::bytesstd::datetimestd::decimalstd::durationstd::float32std::float64std::int16std::int32std::int64std::strstd::uuidFunctionscalmathstdsys
Package: edgerun-ether
ether: Edge Topology SynthesizerEtheris a Python tool to generate plausible edge infrastructure configurations.
It arose from the need to evaluate edge computing systems in different infrastructure scenarios where no appropriate
testbeds are available.Use casesSome of the uses cases foretherincludeEvaluating resource allocation strategiesCreating topologies for network simulationsInfrastructure capacity planingExamplesCode exampleCreating a topology for an urban sensing scenario, similar to that of theArray of Thingscould look like this:topology=Topology()aot_node=IoTComputeBox(nodes=[nodes.rpi3,nodes.rpi3])neighborhood=lambdasize:SharedLinkCell(nodes=[[aot_node]*size,IoTComputeBox([nodes.nuc]+([nodes.tx2]*size*2))],shared_bandwidth=500,backhaul=MobileConnection('internet_chix'))city=GeoCell(5,nodes=[neighborhood],density=lognorm((0.82,2.02)))cloudlet=Cloudlet(5,2,backhaul=FiberToExchange('internet_chix'))topology.add(city)topology.add(cloudlet)We have pre-parameterized versions of these scenarios that can be readily used:topology=Topology()UrbanSensingTopology().materialize(topology)Example usageThe following example shows how we used generated topology to evaluate the effect on uplink usage of different resource
allocation strategies in an edge computing platform.
The node-link diagram of the topology is augmented with atopographic attribute map(rpreiner/tam) that the data exchange in
log bytes.
The left part of the figure shows the baseline resource allocation strategy, the right part shows our improved strategy
that takes data-locality into account.
The visualization helps to see how much the backhaul network is relieved, and how data transfer is isolated into edge
networks.Related publicationsRausch, T., Lachner, C., Frangoudis, P. A., Raith, P., & Dustdar, S. (2020).
Synthesizing Plausible Infrastructure Configurations for Evaluating Edge Computing Systems.
In3rd USENIX Workshop on Hot Topics in Edge Computing (HotEdge 20). USENIX Association.
[Preprint]
Package: edgerun-faas
Edgerun FaaSThis project aims to provide a clear defined API that offers ways of interacting with a FaaS platform (i.e., deploy function)
and expose runtime metrics (i.e., recent invocations) to develop strategies on managing function deployments (i.e., scaling).EdgeRun aims to offer two different (ready-to-use) implementations that stem from completely different backgrounds:galileo-faas: implements this project for a real-world testbed based on Kubernetes andgalileo-experiments.faas-sim: offers a trace-driven, event-based simulation for FaaS.Use casesThe main use case of this project is to clearly define our vision of (1) interacting with a FaaS platform and (2) exposing
runtime metrics to develop novel system components that revolve around scaling, scheduling and load balancing.This translates to the following concrete use cases:You want to deploy, shutdown and invoke a running FaaS platform (withFaaSSystem)You want to implement a scaling/scheduling or load balancing solution that uses runtime metrics (withPlatformContext)
Package: edgerun-galileo-experiments-extensions
Galileo Experiments ExtensionsThis repository contains examples and ready-to-use implementations of Galileo clients for different service to easily start
an experiment.The project mainly depends on thegalileo-experimentsrepository
and should help newcomers to understand the project with ready to go examples!InstructionsFor now all documentation (i.e., infrastructure setup, configurations) can be found in themain project.Run notebooksNotebooks are located innotebooks.
You need to installgalileo-experimentsin editable state to run the notebooks.
Insidenotebooksimport modules fromgalileoexperiments.To install the project (assuming you already created and activated a virtual environment viamake venv):pip install -e .
  ./bin/start-notebook.shThe notebook requires multiple environment variables to fetch data from the data storages.
Therefore, the start script exports those (located inbin/.env) and starts the notebook server.
Checkout themain repositoryfor a detailed description of those.
Package: edgerun-galileo-faas
Galileo FaaSThis project aims to provide easy to use functions to monitor a running K3S cluster, including telemetry data and
traces. The provided functions can help to build intelligent runtime optimizations, i.e., load balancing or scheduling
strategies.For this environment to work, you need to have the following setup:a running K3S clusteran etcd instanceredis for storing nodeinfos and as pub/sub frameworktelemddaemons deployed to monitor resource usagetelemd-kubernetes-adapterdaemon deployed in the Kubernetes
cluster that monitors all Pods an emits events upon changes.In case you want to start a full-fledged experiment withgalileo, you will also
need:InfluxDB to store telemetry, traces and eventsMariaDB for experiment metadataVisit thegalileo-experimentsproject to get further information on
setting up an experiment environment.ExampleLook for an example on how to quickly start all services undergalileofaas.cli.main.InstallationCreate a Python 3.9 virtual environment and installrequirements.txtandrequirements-dev.txt(seeMakefile).HintCurrently you have to install the following dependencies from source:edgerun/faasandedgerun/skippy-core(model-updatesbranch).Environment Variables - Galileo FaaSVariableDefaultDescriptiongalileo_faas_loggingDEBUGLog level (DEBUG, INFO, WARN, ERROR)galileo_faas_telemetry_window_size60the time window that will be cached, in sgalileo_faas_trace_window_size60the time window that will be cached, in sgalileo_faas_redis_hostlocalhostgalileo_faas_redis_port6379galileo_faas_redis_passwordoptionalPassword for Redisgalileo_faas_influxdb_urlhttp://localhost:8086URL to InfluxDB v2 instancegalileo_faas_influxdb_tokentokenToken for InluxDB instancegalileo_faas_influxdb_orgorgInfluxDB organziation to save experiments ingalileo_faas_influxdb_timeout10_000Timeout for InfluxDB connections (in ms)galileo_faas_k8s_configlocalConfigures where the galileo-faas program is started (localorincluster)galileo_faas_etcd_hostlocalhostHost of the Etcd instance (relevant for load balancer to get weights)galileo_faas_etcd_port2379Port of the Etcd instancegalileo_faas_async_podFalseSet to True if Pod creation should by async