Saravanan666/pypi-org huggingface dataset:
Package: eida-statistics-aggregator
# EIDA Statistics aggregationThis project should provide unified statistics about EIDA nodes usage.## Aggregating dataEach EIDA node prepares an aggregation of their logging file using the same script.This aggregation result is sent to a central database through a webservice provided by a central node### Install and executeThis program is intended for python3.6 and more.From [Pypi](https://pypi.org/project/eida-statistics-aggregator/)pip install eida-statistics-aggregator
eida_stats_aggregator –helpAlternatively, if you want to install withpipenv, runpipenv install
pipenv shell
pip install -e .
eida_stats_aggregator –helpFor now, the log file from seiscomp is expected to be a list of JSON entries compressed with BZIP2.### ExemplesAggregate one bz2 seiscomp logfile:eida_stats_aggregator –output-directory aggregates fdsnws-requests.log.2020-11-02.bz2Also available with stdin:cat fdsnws-requests.log.2020-11-02.bz2 |  eida_stats_aggregator –output-directoryYou can also agregate several logfiles:eida_stats_aggregator –output-directory aggregates fdsnws-requests.log.2020-11-02.bz2  fdsnws-requests.log.2020-11-03.bz2### Registering the aggregation to the central statistics serviceIn order to register, you first need a token. Please ask for one by submitting an issue inhttps://github.com/eida/etc/issues/When you have a valid token, you can send all your aggregation files with curl :gunzip -c aggregationfile.json.gz | curl  –header “Authentication: Bearer MYSECRETTOKEN”  –header “Content-Type: application/json” -d “@-”https://ws.resif.fr/eidaws/statistics/1/dataselectstatsThe aggregation script can do this for you on the fly :eida_stats_aggregator -o aggregates fdsn-requests.log.2020-11-02.bz2 –token MYSECRETTOKEN –send-tohttps://ws.resif.fr/eidaws/statistics/1/dataselectstats### TestFrom the projet’s root directory runpipenv install
pipenv shell
python -m pytest tests/test_aggregator.py -s### Aggregation problems#### The Count distinct problemSome information requested by EIDA need to count distint occurences of information (an IP, a country). A naive approach counting distinct occurences on each day and each node can’t be used to count the distinct occurences at a global scale nor for another timewindow.Enters HyperLogLog, an algorithm allowing to estimate occurences for different timeframe. hll is implemented in Python and PostgreSQL this is why this project uses both technologies.#### AnonimizationWe want to anonimize every data that can link to a person. This is why IP adresses are hashed using the same algorithm on each datacenter, in order to have consistant statistics.## Ingesting dataA webservice receiving POST request and ingesting the result in a database## Creating reportsThis code create automatic reports from the database
Package: eidein
eideininteractive tool for dimensionality reduction of data and their visualisationinstallationNeed to install Node.js.Need to install JupyterLab widget manager (seehttps://github.com/matplotlib/ipympl):$ jupyter labextension install @jupyter-widgets/jupyterlab-manager
$ jupyter lab build    # maybeNeed to install Parallel HDF5:$ pip install mpi4py
$ CC="mpicc" HDF5_MPI="ON" pip install --no-binary=h5py h5pydata preparationRunpreparation.ipynbnotebook to createdataset.hdf5with identifiers and redshift.Rundata_extr.py.Rundata_prep.py.
Package: eidolon
EidolonA utility to concurrently make HTTP requests, with an optional rate limit. Powered by asyncio and aiohttp.InstallationInstall and update viapippipinstall--UeidolonA Simple ExampleimportasyncioimportloggingfromeidolonimportParallelizerfromeidolon.api_requestimportAPIRequest"""the callback should ideally be an async function, since methodslike .json or .text on the response are async"""asyncdefcallback(request,response):print(response.status)print(awaitresponse.text())"""Create an APIRequest object. Each object corresponds to a single request, and can take in an optional callbackEverything except request_method and request_url is optional"""req=APIRequest(request_method="GET",request_url="https://www.google.com",request_headers={"User-Agent":"Mozilla/5.0"},request_params={"q":"python"},request_json={"key":"value"},request_form_data={"key":"value"},callback=callback,)p=Parallelizer(logging_level=logging.INFO,# default: logging.ERRORmax_requests_per_second=10,# default: 1max_retry_attempts=1,# default: 3seconds_to_sleep_after_rate_limit_error=10,# default: 15)# make 100 requestsasyncio.run(p.make_requests([req]*100))
Package: eidolon-ai-sdk
EidolonAn Open Source Agent Services FrameworkEidolon makes it easy to build, deploy, and manage agents and other generative ai services.Step 0: PrerequisitesPython 3.11OpenAI api key: You should have an envar OPENAI_API_KEY set to your OpenAI api key.Step 1: Install Eidolon SDKFirst, you need to install the Eidolon SDK. Open your terminal and run the following command:pipinstalleidolon-ai-sdkStep 2: Create an AgentNow it is time to create your firstAgentProgram. Create a directory and add a yaml file to describe your resource.mkdirhello_world
vimhello_world/hello_world_agent.yamlapiVersion:eidolon/v1kind:Agentmetadata:name:hello_worldspec:description:"Thisisanexampleofagenericagentwhichgreetspeoplebyname."system_prompt:"Youareafriendlygreeterwhogreetspeoplebynamewhileusingemojis"actions:user_prompt:"Hi,mynameis{{name}}"Step 3: Run Eidolon ServerFinally, open a new terminal window and run your machine using eidolon-server.eidolon-server-mlocal_devhello_world🚨 Gettingcommand not found: eidolon-server? Open a new terminal window and try the command again.⚠️ The-m local_devoption specifies using thelocal_devbuiltin Machine resource. This machine uses in-memory symbolic memory rather than mongo, so state will disappear between server restarts.Step 4: Try it out!First create a process for your conversation.curl-XPOSThttp://0.0.0.0:8080/agents/hello_world/processes;echoThe result should be a json object with a process id. For example:{"process_id":"hello_world-1"}Now let's try to make a request to your server from another terminal window.curl-XPOSThttp://0.0.0.0:8080/agents/hello_world/processes/{process_id}/actions/converse-H'Content-Type: application/json'-d'{"name": "World"}';echoReplace{process_id}with the process id you received from the previous command.You should now see something likeHello, World! 🌍👋And that's it! You have successfully set up and used a basic project using the Eidolon SDK. To see more endpoints on your agent machine, visit theswagger ui.Further ReadingFor full documentation, visitwww.eidolonai.com.
Package: eidolon-savegame-editor
Early in my playing of Eidolon, I somehow missed my chance to find the
fishing pole and continually had trouble finding enough food to survive
as a result.  This is the tool I wrote to avoid having to trek all
the way across the world to find that fishing pole.InstallFrom any environment where pip is available:pip install eidolon-savegame-editorOr, from a clone of this repository:pip install -e .Useeidolon_savegame_editor /path/to/savegame COMMANDBut where’s my savegame?OSPathOSX~/Library/Application Support/Steam/SteamApps/common/Eidolon/EIDOLON.app/Contents/Resources/Engine/Config/SaveData.binWindowsC:\UDK\EIDOLON\Binaries\Win32\SaveData.binCommandsreset_hungerResets your hunger to zero.add_items ITEM COUNTAdds items to your inventory.Options forITEMinclude:MushroomsTinderCookedFishHoneyorany other item in your inventory; use the key_itemsinshow_propertiesto see what’s in your inventory currently.Note: If the item name you enter is not something that exists in
Eidolon, it will be ignored by the game, but will stay in your
savegame file forever.add_tool TOOLAdds a tool to your inventory.Options forTOOLinclude:nocsrodcompassbowshow_propertiesEnumerates properties found in the savegame file.DisclaimerThis may destroy your savegame!  Make a backup if you don’t trust this script.
Package: eidreader
eidreader is a command-line script that reads data from Belgian eID cards and
writes the data to stdout or posts it to a web server. It is designed to be used
together with a web application that will process the data.Not to be mixed up with its deprecated Java predecessoreidreader(same project name but
another account).The central project homepage ishttps://eidreader.lino-framework.orgPlease report issues tohttps://github.com/lino-framework/eidreader/issuesThis script was written and is maintained by Luc Saffre <luc@saffre-rumma.net>.Thanks to Vincent Hardy (vincent.hardy.be@gmail.com)
Package: eiffel2
Eiffel2current version: 0.0.3Next release: 19/11/2020Neural Network architecture  Visualization tool :GithubYou can use eiffel2, which you can install using pip:python-mpipinstalleiffel2to update eiffel:python-mpipinstalleiffel2--upgradeJust import builder from eiffel and provide a list of neurons per layer in your network as an input.Example:fromeiffel2importbuilderbuilder([1,10,10,5,5,2,1])# or the following if you want to have a dark themebuilder([1,10,10,5,5,2,1],bmode="night")output:(normal mode)output:(with bmode="night')COLORS:You can add colors to your network with the net_colors variable inbuilder(), keep in mind that for a n layer network you
must select n-1 colors
Eiffel2 is compatible with vanila python colors ("red","blue") and Hex colorsOnline Color toolEXAMPLEfromeiffel2importbuilderbuilder([1,6,6,5,2],net_colors=["#581845","#900C3F","red","#FF5733"])output:
Package: eiffel-framework
eiffelEvaluation framework for FL-based intrusion detection using Flower.UsageAs a toolYou can useeiffelas an experiment engine.
To do so, you need to provide a configuration file entitledconfig.yaml, which will be passed to Hydra.python-meiffel-cdpath/to/workdir/By default,eiffelwill look for a Git repository, either in the current directory or in one of its parents.
The root of the repository will be used as the working directory for Hydra, meaning that the defaultoutputs/andmultirun/directories will be created there.As a libraryReadings for the integration with HydraHydra: Your Own Configuration Files — Maze documentationHydra: Your Own Configuration Files — Maze documentationExperiment Configuration — Maze documentationConfiguring Experiments | Hydra
Package: eigenapi-client
EigenAPI-Clienteigenapi-client is a python wrapper ofEigenAPI.Github repository of this project is located athttps://github.com/eigenphi/eigenapi-client.The repo maybe not open sourced currently, and we are planning to open it.Install eigenapi-clientYou can install eigenapi-client by:pipinstalleigenapi-clientWe published this python lib to pypi.You can find it atPypi PageDocument of EigenAPIAPI Document can be foundhere
Package: eigendata
IntroductionProduct managers, business analysts, operations managers, and other non-technical personas often need to analyze data or complete repetitive tasks in the context of a business process.This is often done in spreadsheets in a way that is not scalable or robust. To overcome challenges found in spreadsheets, many have learned basic coding.Butfor these "semi-technical" users, the cognitive overhead of remembering code syntax is often too high, hampering their productivity.Eigendata empowers "semi-technical" users with a Python low-code tool that makes manipulating data as easy as spreadsheets, without any of the limitations.You can easily do a quick and dirty analysis without having to deal with the overhead of remembering basic python syntaxIf you need to automate the process, you can leverage the underlying code generated  using the tool to turn the transformations into a repeatable process.If the process needs to be "productionized" by an engineering they can start from a code-base based on standard python packagesEigendata JupyerLab ExtensionEigendata renders a low-code interface below cells in aJupyterLab Notebook, providing fast access to common data transformations without needing to remember the syntax or the exact name of the method.Open a JupyerLab notebook, and you will seeBesides these improvements,Eigendata provides options to simplify the JupyterLab experiencefor new users:Intuitive shortcuts for the sidebars⌘ /⌘ \When you close a tab, the kernel is shut downAll of these configurations can also be disabled through the advanced settings⌘ ,InstallYou can try a free cloud instancehereor install with pippipinstalleigendataEigendata Core: Framework for declarative GUIsEigendata is built on top of an extensible framework to render Python methods as GUIs.To use your own custom transformations:You can add the JSON code to user transformations in the settings of the eigendata extension.If you want to share transformations across a team (e.g. common features), you can also provide a transformation sever URL that serves a file with the transformations. This can be set up with thetransformationServerandtransformationAuthin eigendata settings.You can learn more about the transformation UI spec and how to create your own transformations in ourtransformation documentation.Example transformation UI from a JSON definition:"pandas.DataFrame.drop":{"form":{"required":["columns"],"definitions":{"columns":{"type":"array","uniqueItems":true,"items":{"type":"string","enum":[]}}},"properties":{"columns":{"$ref":"#/definitions/columns","description":"Select the columns that you want to remove."}},"title":"Drop columns","description":"Drop columns from the dataframe.","type":"object","callerObject":"DataFrame","returnType":"DataFrame","function":"drop"}}And the UI rendered based on this definition:RequirementsJupyterLab >= 3.0Pandas, Numpy,Fastdata(our own library with pandas utilities)Uninstallpipuninstalleigendata
Package: eigenmorphic
Eigenvalues of morphic subshifts.This is a Sage optional package.
It contains code to compute exact additive eigenvalues
of morphic subshifts, that is a substitution subshift or
the subshift generated by its image by another substitution.Installation:sage -pip install eigenmorphicUsage:sage: from eigenmorphic import *After this command, you can compute eigenvalues of morphic subshifts:sage: s = WordMorphism("a->ab,b->ac,c->a")
sage: morphic_eigenvalues(s)
Z*{1, b, b^2}
    where b is root of x^3 - x^2 - x - 1

    sage: t = WordMorphism('a->0,b->1,c->1')
    sage: morphic_eigenvalues(s, t)
    Z*{1, b, b^2}
    where b is root of x^3 - x^2 - x - 1

    sage: # regular paperfolding
    sage: t = WordMorphism('a->00,b->01,c->10,d->11')
    sage: s = WordMorphism('a->ca,b->cb,c->da,d->db')
    sage: t(s.fixed_points()[0])
    word: 1101100111001001110110001100100111011001...
    sage: morphic_eigenvalues(s,t)
    1/8Z[1/2]
Package: eigenpip
eigenpip: Recent Version of Eigen Library for PythonMohan Wu, Martin LysyDescriptioneigenpipis a recent distribution of theC++ Eigen libraryfor Python linking. Some applications of the library can be found in ourKalman package. There are two main functions toeigenpip. The first is installing the Eigen library to give access to other Python packages. The second is give the user access to the path of the Eigen library.InstallationTo instal from pypi:pipinstalleigenpipFor a normal installation:gitclonehttps://github.com/mohanwu/eigenpipcdeigenpip
pipinstall.If you would like to your own version of the Eigen library then set the environment variableEIGEN_PATHto the path of your library.On Linux:EIGEN_PATH="/ABSOLUTE/PATH/TO/EIGEN/LIBRARY"pipinstall.On Windows Powershell:$env:EIGEN_PATH="/ABSOLUTE/PATH/TO/EIGEN/LIBRARY";pipinstall.UsageTo get the path of the Eigen library:importeigenpipEIGEN_PATH=eigenpip.get_include()
Package: eigenpy
EigenPy — Versatile and efficient Python bindings between Numpy and EigenEigenPyis an open-source framework that allows the binding of the famousEigenC++ library in Python via Boost.Python.EigenPyprovides:full memory sharing between Numpy and Eigen, avoiding memory allocationfull support Eigen::Ref avoiding memory allocationfull support of the Eigen::Tensor moduleexposition of the Geometry module of Eigen for easy code prototypingstandard matrix decomposion routines of Eigen such as the Cholesky decomposition, SVD decomposition, QR decomposition, etc.full support of SWIG objectsfull support of runtime declaration of Numpy scalar typesextended API to expose std::vector typesfull support of vectorization between C++ and Python (all the hold objects are properly aligned in memory)SetupThe installation ofEigenPyon your computer is made easy for Linux/BSD, Mac OS X, and Windows environments.The Conda approachYou simply need this simple line:condainstalleigenpy-cconda-forgeUbuntuYou can easily installEigenPyfrom binaries.Add robotpkg apt repositoryAdd robotpkg as source repository to apt:sudo sh -c "echo 'deb [arch=amd64] http://robotpkg.openrobots.org/packages/debian/pub $(lsb_release -cs) robotpkg' >> /etc/apt/sources.list.d/robotpkg.list"Register the authentication certificate of robotpkg:curl http://robotpkg.openrobots.org/packages/debian/robotpkg.key | sudo apt-key add -You need to run at least one apt update to fetch the package descriptions:sudoapt-getupdateInstall EigenPyThe installation ofEigenPyand its dependencies is made through the line:sudoaptinstallrobotpkg-py35-eigenpywhere 35 should be replaced by the Python 3, you want to work this (e.g.,robotpkg-py36-eigenpyto work with Python 3.6).Mac OS XThe installation ofEigenPyon Mac OS X is made viaHomeBrew.
You just need to register the tap of the software repository.brew tap gepetto/homebrew-gepettoand then installEigenPyfor Python 3.x with:brew install eigenpyCreditsThe following people have been involved in the development ofEigenPy:Justin Carpentier(Inria): main developer and manager of the projectNicolas Mansard(LAAS-CNRS): initial project instructorWolfgang Merkt(University of Edinburgh): ROS integration and supportSean Yen(Microsoft): Windows integrationLoïc Estève(Inria): Conda integrationWilson Jallet(Inria/LAAS-CNRS): core developerJoris Vaillant(Inria): core developer and manager of the projectIf you have taken part in the development ofEigenPy, feel free to add your name and contribution here.AcknowledgmentsThe development ofEigenPyis supported by theGepetto team@LAAS-CNRSand theWillow team@INRIA.
Package: eigenstrapping
Theeigenstrappingtoolbox is designed to help researchers generate
statistically-rigorous models for null hypothesis testing between brain maps using
non-local spectral shape descriptors - or geometric eigenmodes.
Documentation can be foundhere.FeaturesA growing library of eigenmodes of standard surfaces and surface densities (fsaverage, fsLR)Cortical and subcortical null models for assessing statistical correspondence between brain mapsGeneration of geometric eigenmodes on user-derived surfacesInstallation GuideEigenstrapping is available in Python 3.7+. MATLAB version coming soon!DependenciesTo install eigenstrapping, the following Python packages are required:numpyscipyscikit-learnlapymatplotlibnibabelnilearnpandasbrainspacenetneurotoolsnibabelandnilearnare required for surfaces and volumes.matplotlibis only required for fitting plots infit.pyand some of the surface
plotting functions. Future improvements will reduce the number of dependencies
needed.Additional dependenciesConnectome WorkbenchFreeSurfer 6.0.0+Installationeigenstrapping can be installed usingpip:pip install eigenstrappingAlternatively, you can install the package from the Github repository:git clone https://github.com/SNG-newy/eigenstrapping.git
cd eigenstrapping
python setup.py installCitingWhen usingeigenstrapping, please cite the following manuscript:nullAnd please also cite the papers for the method that we use to calculate eigenmodes
on the surface:Laplace-Beltrami spectra as ‘Shape-DNA’ of surfaces and solids. Reuter M, Wolter F-E, Peinecke N. Computer-Aided Design. 2006;38(4):342-366.http://dx.doi.org/10.1016/j.cad.2005.10.011BrainPrint: a discriminative characterization of brain morphology. Wachinger C, Golland P, Kremen W, Fischl B, Reuter M. Neuroimage. 2015;109:232-48.http://dx.doi.org/10.1016/j.neuroimage.2015.01.032http://www.ncbi.nlm.nih.gov/pubmed/25613439License informationThis work is licensed under a
Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Licensecc-by-nc-sa.
The full license can be found in theLICENSEfile in theeigenstrappingdistribution.
Package: eigentools
EigentoolsEigentools is a set of tools for studying linear eigenvalue problems. The underlying eigenproblems are solved usingDedalus, which provides a domain-specific language for partial differential equations. Eigentools extends Dedalus'sEigenvalueProblemobject and providesautomatic rejection of unresolved eigenvaluessimple plotting of specified eigenmodessimple plotting of spectracomputation of pseudospectra for any Differential-Algebraic Equations withuser-specifiable normstools to find critical parameters for linear stability analysisability to project eigenmode onto 2- or 3-D domain for visualizationability to output projected eigenmodes as Dedalus-formatted HDF5 file to be used as initial conditions for Initial Value Problemssimple plotting of drift ratios (both ordinal and nearest) to evaluate tolerance for eigenvalue rejectionInstallationEigentools can bepipinstalled, though it requiresDedalus, which has non-pipinstallable dependencies. See theinstallation instructionsfor details.DocumentationDocumentation (including detailed API documentation) can be found atRead the Docs.If you are upgrading from version 1 to version 2, you can find a guide to API changeshereContributingEigentools welcomes community contributions from issue reports to code contributions. For details, please seeour contribution policy.DevelopersThe core development team consists ofJeff Oishi (jsoishi@gmail.com)Keaton Burns (keaton.burns@gmail.com)Susan Clark (susanclark19@gmail.com)Evan Anders (evan.anders@northwestern.edu)Ben Brown (bpbrown@gmail.com)Geoff Vasil (geoffrey.m.vasil@gmail.com)Daniel Lecoanet (daniel.lecoanet@northwestern.edu)SupportEigentools was developed with support from the Research Corporation under award Scialog Collaborative Award (TDA) ID# 24231.
Package: eiger-simulator
Eiger simulatorDectris Eiger detector simulator.For now simulates Eiger 9M at full ROI in internal trigger single mode (ints).Complete HTTP REST API + ZMQ data stream.InstallationFrom within your favorite python environment:$pipinstall-eeiger-simulatorIf you need the client library, you need in addition:$pipinstall-eeiger-simulator[client]UsageRun simulator with:$eiger-simulator--dataset=<pathtotheHDF5masterfile>--max-memory=1_000_000_000This will start a simulator listening to the HTTP interface on port 8000 and the
ZMQ streaming socket on TCP port 9999Run with--helpto see the complete list of options$eiger-simulator--help
Usage:eiger-simulator[OPTIONS]Options:--hostTEXTBindwebsockettothishost.[default:0]--portINTEGERBindwebsockettothisport.[default:8000]--zmqTEXTBindZMQsocket[default:tcp://*:9999]--datasetPATHdatasetpathorfile--max-memoryINTEGERmaxmemory(bytes)[default:1000000000]--log-level[critical|error|warning|info|debug|trace]ShowonlylogswithpriorityLEVELorabove[default:info]--helpShowthismessageandexit.ClientThe client is accessible as a python library:>>>fromeigersim.clientimportEiger>>>eiger=Eiger('http://127.0.0.1:8000')>>>eiger.initialize()[response200]>>>eiger.nimages100>>>eiger.count_time0.1>>>eiger.trigger_mode'ints'>>>eiger.arm()[response200]>>>eiger.trigger()[response200]Note that you should be able to use the client to connect to a real Eiger detector, not just
the simulated one.For reference, here is a simple client that listens to the ZMQ stream:>>>importzmq>>>ctx=zmq.Context()>>>sock=ctx.socket(zmq.PULL)>>>sock.connect('tcp://127.0.0.1:9999')>>>whileTrue:data=sock.recv_multipart()size=sum(len(i)foriindata)print(f'packet #parts={len(data)}size={size/1000}KB')BenchmarksBenchmark results availablehere.
Package: eight2
eight2Python Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://eight2.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-01-01)First release on PyPI.