Saravanan666/pypi-org huggingface dataset:
Package: eulexistdb
packagedocumentationcodeEULexistdb is aPythonmodule that
provides utilities and classes for interacting with theeXist-db XML
Database(tested against version 2.2) in a
pythonic, object-oriented way, with optionalDjangointegration.eulexistdb.dbprovides access to an eXist-db instance through
eXist’sXML-RPC API.eulexistdb.queryprovides aQuerySetclass modeled afterDjango QuerySetin
functionality.  This module providesmodelandmanagerclasses
that can be used to connect aneulxmlXmlObjectwith theQuerySetclass, in order to generate XQueries and return the
results as XmlObject instances.  However, configuring the XmlObject
XPaths to make efficent XQueries against eXist and take advantage of
the full-text index does require expertise and familiarity with eXist.When used withDjango,eulexistdbcan pull the database connection configuration from
Django settings, provides a custom management command for working with
the collection index configuration index in the configured eXist
database, and also provides a custom template tag that can be used to
highlight full-text search matches.Dependencieseulexistdbcurrently depends oneulxml.eulexistdbcan be used withoutDjango, but additional
functionality is available when used with Django.Contact Informationeulexistdbwas created by the Digital Programs and Systems Software
Team ofEmory University Libraries.libsysdev-l@listserv.cc.emory.eduLicenseeulexistdbis distributed under the Apache 2.0 License.Development HistoryFor instructions on how to see and interact with the full development
history ofeulexistdb, seeeulcore-history.Developer notesTo install dependencies for your local check out of the code, runpip installin theeulexistdbdirectory (the use ofvirtualenvis recommended):pip install -e .If you want to run unit tests or build sphinx documentation, you will also
need to install development dependencies:pip install -e . "eulexistdb[dev]"Running the unit tests requires an eXist-DB database instance.  Before running tests, you will
need to copytest/localsettings.py.disttotest/localsettings.pyand edit the
configuration for your test instance of eXist.To run all unit tests:nosetests test/ # for normal development
nosetests test/ --with-coverage --cover-package=eulexistdb --cover-xml --with-xunit   # for continuous integrationTo run unit tests for a specific module, use syntax like this:nosetests test/test_existdb/test_db.pyTo generate sphinx documentation:cd doc
make html
Package: eulfedora
packagedocumentationcodeeulfedora is aPythonmodule that provides
utilities, API wrappers, and classes for interacting with theFedora-Commons Repositoryin a pythonic, object-oriented way, with optionalDjangointegration.  Current versions
of eulfedora are intended for use with Fedora Commons 3.7.x or 3.8.x, but
will likely work with earlier versions.  If you need support for an earlier
version of Fedora and the latest eulfedora does not work, you may have
success with the 1.0 release.eulfedora.apiprovides complete access to the Fedora API,
primarily making use of Fedora’sREST API.  This
low-level interface is wrapped byeulfedora.server.Repositoryandeulfedora.models.DigitalObject, which provide a more abstract,
object-oriented, and Pythonic way of interacting with a Fedora
Repository or with individual objects and datastreams.eulfedora.indexdataprovides a webservice that returns data for
fedora objects in JSON form, which can be used in conjunction with a
service for updating an index, such aseulindexer.When used withDjango,eulfedoracan pull the Repository connection configuration from
Django settings, and provides a custom management command for loading
simple content models and fixture objects to the configured
repository.Dependencieseulfedoracurrently depends oneulxml,rdflib,python-dateutil,pycrypto,soaplib.eulfedoracan be used withoutDjango, but additional
functionality is available when used with Django.Contact Informationeulfedorawas created by the Digital Programs and Systems Software
Team ofEmory University Libraries.libsysdev-l@listserv.cc.emory.eduLicenseeulfedorais distributed under the Apache 2.0 License.Development HistoryFor instructions on how to see and interact with the full development
history ofeulfedora, seeeulcore-history.Developer NotesTo install dependencies for your local check out of the code, runpip installin theeulfedoradirectory (the use ofvirtualenvis recommended):pip install -e .If you want to run unit tests or build sphinx documentation, you will also
need to install development dependencies:pip install -e . "eulfedora[dev]"Running the unit tests requires a Fedora Commons repository instance.  Before
running tests, you will need to copytest/localsettings.py.disttotest/localsettings.pyand edit the configuration for your test repository.To run the tests, you should set an environment variable ofDJANGO_SETTINGS_MODULEequal totestsettings.testor prefix
the nosetests command withenv DJANGO_SETTINGS_MODULE=testsettings.test.To run all unit tests:nosetests test # for normal development
nosetests test --with-coverage --cover-package=eulfedora --cover-xml --with-xunit   # for continuous integrationTo run unit tests for a specific module or class, use syntax like this:nosetests test.test_fedora.test_api
nosetests test.test_fedora:TestDigitalObjectTo generate sphinx documentation:cd doc
make htmlTo upload a tagged release toPyPIwith
awheelpackage:python setup.py sdist bdist_wheel uploadTo upload new artifacts for previously published versions, usetwine.
Package: eulith-web3
Welcome To Eulith ClientPlease find our docs athttps://docs.eulith.comSetup for Linux 22.04sudo apt update -qq
sudo apt install -qq -y python3 python3-pip
pip3 install pyproject.toml
pip3 install web3
pip3 install pytest
export PATH=$PATH:$HOME/.local/bin   ; echo consider adding this to .bashrcRunning testspytestor if you use a different URL for where to find the eulith call serverEULITH_URL=http://192.168.244.44:7777/v0 pytest
Package: eulxml
packagedocumentationcodeeulxml is aPythonmodule that provides
utilities and classes for interacting with XML that allow the
definition of re-usable XML objects that can be accessed, updated and
created as standard Python types, and a form component for editing XML
withDjangoforms.eulxml.xpathprovides functions and classes for parsing XPath
expressions usingPLY.eulxml.xmlmapmakes it easier to map XML to Python objects in a
nicer, more pythonic and object-oriented way than typical DOM access
usually provides.  XML can be read, modified, and even created from
scratch (in cases where the configured XPath is simple enough to
determine the nodes that should be constructed).eulxml.formsprovides Django Form objects that useeulxml.xmlmap.XmlObjectinstances as the basis and data instance
for the form, with the goal of making it easy to edit XML content
via web forms.Dependencieseulxmldepends onPLYandlxml.eulxml.formsrequires and was designed to be used withDjango, although Django is not
required for installation and use of the non-form components ofeulxml.Contact Informationeulxmlwas created by the Digital Programs and Systems Software
Team ofEmory University Libraries.libsysdev-l@listserv.cc.emory.eduLicenseeulxmlis distributed under the Apache 2.0 License.Development HistoryFor instructions on how to see and interact with the full development
history ofeulxml, seeeulcore-history.Developer notesAs of version 1.1, eulxml provides anXML catalogfor loading schemas referenced by included XmlObject instances.Requestsis required for downloading schemas, but it is not a dependency of eulxml. The
catalog and schemas will be included in distributed releases, but if you
want to use the catalog when installing directly from GitHub you can
use a normal pip install and then run:python -c 'from eulxml.catalog import generate_catalog; generate_catalog()'To install dependencies for your local check out of the code, runpip installin theeulxmldirectory (the use ofvirtualenvis recommended):pip install -e .If you want to run unit tests or build sphinx documentation, you will also
need to install development dependencies:pip install -e . "eulxml[dev]"To run all unit tests:nosetests   # for normal development
nosetests --with-coverage --cover-package=eulxml --cover-xml --with-xunit   # for continuous integrationTo run unit tests for a specific module, use syntax like this:nosetests test/test_xpath.pyTo generate sphinx documentation:cd doc
make html
Package: eumdac
EUMDAC - EUMETSAT Data Access ClientEUMDACis theEUMETSATDataAccessClient. It provides simple access to the EUMETSAT data of all satellite missions. As aPython library, it comes with many methods and helpers to use EUMETSATs APIs and services, like Data Store and Data Tailor. As aCLI, it provides a variety of useful command line utilities for data search, translation and processing.Check theEUMDAC knowledge basefor more information on installing and using the CLI and library.PrerequisitesYou will need a python environment to run the library implementation of this code. EUMDAC requires Python 3.7 or higher. We recommend that you install the latest Anaconda Python distribution for your operating system (https://www.anaconda.com/). No prerequisites are identified for running the CLI binary.Installing the EUMDAC library and CLIInstalling with PIPThe EUMDAC Python package is available throughPyPI:pipinstalleumdacInstalling with CondaTo install EUMDAC on the Anaconda Python distribution, please visit theEUMETSAT conda-forge pagefor install instructions.condainstall-ceumetsat-forgeeumdacInstalling from sourceTo install EUMDAC from the development source, clone the repository and install it locally.gitclonehttps://gitlab.eumetsat.int/eumetlab/data-services/eumdac.gitcdeumdac
pipinstall.Using the EUMDAC CLI binaries (no installation required)If an installation of EUMDAC is not possible due to missing technical prerequisites, we recommend to use our binaries. These executable applications allow you to use all the functions of the CLI without installation.The binaries are available for Windows, Linux and Mac in theReleases section.You can find more information in theEUMDAC knowledge base.ContributingIf you feel like something is missing, should work differently or you find a bug in EUMDAC you are encouraged to provide feedback to the development team on EUMDAC. Please contact us via theEUMETSAT User Support Helpdeskif you have suggestions or questions.AuthorsCarlos HornBen LovedayNiklas JordanPaulo CarmoChristopher SalomanMatthias SchwarzEoin O'NeillPramit GhoshLuisa AraujoJoaquin Rodriguez-Guerra-EUMETSATRafa de la Hoz-EUMETSATDependenciesrequests,   ver. 2.26.0, License: Apache-2.0 (LICENSE_APACHE_v2.txt), Copyright 2014 Kenneth Reitz,   info:https://anaconda.org/conda-forge/requestsresponses,  ver. 0.16.0, License: Apache-2.0 (LICENSE_APACHE_v2.txt), Copyright 2015 David Cramer,    info:https://anaconda.org/conda-forge/responsessetuptools, ver. 58.0.4, License: MIT (LICENSE_MIT.txt),              Copyright 2020 Jason R. Coombs, info:https://anaconda.org/conda-forge/setuptoolsLicenseThis code is licensed under an MIT license. See file LICENSE.txt for details on the usage and distribution terms. No dependencies are distributed as part of this package.All product names, logos, and brands are property of their respective owners. All company, product and service names used in this website are for identification purposes only
Package: eumetsat2ani
eumetsat2aniCreate animations directly from EUMETSAT data from the command line:python-meumetsat2ani\--api-key<eumetsat-api-key>\--api-secret<eumetsat-api-secret>\--collection-nameEO:EUM:DAT:MSG:HRSEVIRI\--t-start2015-04-14T09:00:00\--t-end2015-04-14T12:00\--areaeuro\--productnatural_colorTo get your API keys for EUMETSAT you will need to create an account and go tohttps://api.eumetsat.int/api-key/.Installationeumetsat2anican be installed directly withpippython-mpipinstalleumetsat2aniUsagepython-meumetsat2ani--help
usage:__main__.py[-h]--api-keystr--api-secretstr[--collection-namestr][--t-startparse_datetime][--t-endparse_datetime][--areastr][--root-data-pathPath][--productstr][--launch-ipdb-on-error][--frame-durationfloat]options:-h,--helpshowthishelpmessageandexit--api-keystrEUMETSATAPIkey(default:None)--api-secretstrEUMETSATAPIsecret(default:None)--collection-namestrEUMETSATcollectionname(default:EO:EUM:DAT:MSG:HRSEVIRI)--t-startparse_datetimeStarttime(default:2015-04-14T09:00:00)--t-endparse_datetimeEndtime(default:2015-04-14T13:00:00)--areastrAreadefinition(usingsatpy'sinbuiltareadefinitions)(default:euro)--root-data-pathPathRootpathtostoredownloadeddata(default:data)--productstrSatpyproducttorender(default:natural_color)--launch-ipdb-on-errorLaunchipdbonerror(default:False)--frame-durationfloatDurationofeachframeinseconds(default:0.5)Inspirationhttps://eumetsatspace.atlassian.net/wiki/spaces/EUMDAC/pages/1760198661/Python+Libraryhttps://gitlab.eumetsat.int/eumetlab/data-services/eumdac_data_store
Package: eummd
eummdDescriptionComputes maximum mean discrepancy two-sample test for univariate data using the Laplacian kernel. It is also possible to compute the p-value using permutations. Also includes implementation for computing the robust median difference statistic 'Q_n' from Croux and Rousseeuw (1992)doi:10.1007/978-3-662-26811-7_58based on Johnson and Mizoguchi (1978)doi:10.1137/0207013.Installation instructionsInstall usingpip:python3 -m pip install eummdMethods are implemented in C++, and then called using Cython.FunctionsThere are various functions for computing the maximum mean discrepancy (MMD).eummd: efficient univariate MMD with the Laplacian kernel, O(n log n)
for a total of n samples.mmd: MMD (univariate/multivariate).meammd: multivariate efficient approximate MMD, using either random
projections or interpoint distances.mediandiff: computes the median difference. If univariate, can
be computed in O(n log n), otherwise is O(n^2).medianheuristic: the inverse of the median difference.eummdandmmdreturn a dictionary with the itemspvalfor
p-value (if specified),statfor the statistic andbetafor the
kernel parameter value that was used. Ifbetais specified as a
non-positive number, then the median heuristic will be calculated.Examples:from eummd import eummd
from eummd import mediandiff

X = np.array([7.1, 1.2, 4.3, 0.4]).astype(np.float64)
Y = np.array([5.5, 2.6, 8.7]).astype(np.float64)
beta = 0.1

# only computes statistic, 
d = eummd(X, Y, beta, pval=False)
print(d['stat'])

# computes statistic and p-value, and used median heuristic for beta
d = eummd(X, Y, beta=-0.1, pval=True)
print("p-value for univariate data: ", d['pval'])
print("statistic for univariate data: ", d['stat'])
print("beta for univariate data: ", d['beta'])

# show median heuristic was used
print(1.0 / mediandiff(X, Y, fast=True))

# a multivariate example, using median heuristic for beta
X = np.array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]).reshape((6, 2))
Y = np.array([[13, 14, 15, 16], [17, 18, 19, 20]]).reshape((4, 2))

d = mmd(X=X, Y=Y, beta=-0.5, pval=True, kernel="Laplacian")
print("p-value for multivariate data: ", d['pval'])
print("statistic for multivariate data: ", d['stat'])
print("beta for multivariate data: ", d['beta'])
Package: eunomia
📜 EunomiaA sane but flexible configuration framework.Visit thedocsfor more info.OverviewSimpleHydrainspired configuration
library, supporting custom backends and variable substitution. Configs are defined as nested groups of mutually exclusive options
that can be selectively activated.The Horai, as they are called, to each of them, according as her name
indicates, was given the ordering and adornment of life, so as to serve to
the greatest advantage of mankind; for there is nothing which is better to
build a life of felicity than obedience to law (Eunomia) and justice (Dike)
and peace (Eirene).
—Diodorus SiculusGetting StartedInstall with:pip install eunomiaVisit thedocs!Citing EunomiaPlease use the following citation if you use Eunomia in your research:@Misc{Michlo2021Eunomia,author={Nathan Juraj Michlo},title={Eunomia - A sane but flexible configuration framework},howpublished={Github},year={2021},url={https://github.com/nmichlo/eunomia}}
Package: euphonic
Euphonic is a Python package that can efficiently calculate phonon
bandstructures, density of states and inelastic neutron scattering
intensities from force constants. The force constants can be read
from various sources, including CASTEP.castep_binfiles, or Phonopyphonopy.yamlfiles. While Euphonic is primarily a library, multiple
command-line tools are also provided for convenient plotting of the above
quantities.For more information, see thedocs.
Package: euphony
EuphonyHave you ever got bored of running long chunks of code?It can get repetitive to monitor the progress of the code continuously.Euphony can help you. It is a Python package that plays classical
music in background while your code runs whether it be on terminal
or script or jupyter notebook. Once your code is complete
or if it errors out, it stops so you can go back to it.How to useIts pretty simple to use. Create a instance of theplayerclass and let your code run enclosed
in awithstatement with the object. You can choose betweenbach,beethovenormozart. If not specified, it chooses at random.fromeuphony.playerimportPlayermozart=Player(artist='mozart')# options: ['bach', 'beethoven']withmozart:foriinrange(1000000000):pass# plays music while the code runsThat's all ~!Note: Since it requires native audio output, you cannot use this when running code remotely like on AWS.InstallationEuphony is pip-installable. Just run following cmd in terminal:pipinstalleuphonyDocumentationLink to Documentation
Package: euporie
euporieEuporie is a terminal based interactive computing environment for Jupyter.Euporie’s apps allow you to interact with Jupyter kernels, and run Jupyter notebooks - entirely from the terminal.If you’re working with Jupyter notebooks in a terminal only environment, like an SSH server or a container, or just prefer working in the terminal, then euporie is the tool for you!ConsoleNotebookPreviewHubView more screenshots hereInstallYou can install euporie withpipx(recommended) orpip:$pipxinstalleuporie$# OR$python-mpipinstall--usereuporieYou can also try euporie onlinehere.FeaturesEdit and run notebooks in the terminalRun code interactively in a consoleDisplay images using terminal graphics (sixel / iterm / kitty)Use Jupyter widgets interactively in the terminalRender rich kernel output (markdown, tables, images, LaTeX, HTML, SVG, & PDF)Tab-completion, line suggestions  and contextual helpConvert a console session to a notebookMicro / Vim / Emacs style key-bindingsUsageNotebooksYou can edit a notebook usingeuporie-notebook, and passing the notebook’s file path or URI as a command line argument:$euporie-notebooknotebook.ipynbAlternatively, launcheuporie-notebooksand open a notebook file by selecting “Open” from the file menu (Ctrl+O).ConsoleTo connect to a Jupyter kernel and run code interactively in a console session, you can run$euporie-console(You can pressCtrl+Cto open the command palette ineuporie-console).PreviewTo preview a notebook to the terminal, use theeuporie-previewsubcommand:$euporie-previewnotebook.ipynbHubTo run euporie hub, a multi-user SSH server for euporie apps, run:$euporie-hub--port8022--host-keys=ssh_host_ed25519_key--client-keys=authorized_keyswheressh_host_ed25519_keyis the path to your host key file, andauthorized_keysis a file containing SSH public keys allowed to connect.DocumentationView the online documentation at:https://euporie.readthedocs.io/The code is available on GitHub at:https://github.com/joouha/euporieCompatibilityEuporie requires Python 3.8 or later. It works on Linux, Windows and MacOS
Package: eurec4a-synop
Synoptic charts for the EUREC4A field campaignWith this package you can add synoptic charts to any cartographic matplotlib
plot. The charts were provided by Cécile MARIE-LUCE at Meteo-France, Guadeloupe
and generated as part of theforecasting
testbedduring theEUREC4Afield-campaign by theEUREC4A-UKteam. The synoptic charts were created from
analysis at 00:00UTC and cover January 1st to February 29th 2020.InstallationThe package can be installed with pip from pypipython-mpipinstalleurec4a_synopTo use it simply importeurec4a_synopand calladd_synopimportcartopy.crsasccrsimportmatplotlib.pyplotaspltimporteurec4a_synopcrs=ccrs.AzimuthalEquidistant(central_latitude=10.0,central_longitude=-45.0)fig,ax=plt.subplots(subplot_kw=dict(projection=crs),figsize=(14,16))ax.set_extent([-80,-10,0,30],crs=ccrs.PlateCarree())add_synop(ax=ax,date=datetime.datetime(year=2020,month=2,day=2))ax.coastlines()ax.gridlines(draw_labels=True)
Package: eureeka
A proof-of-concept implementation of a novel AI theory of emergent knowledge representation and processing (i.e., meaningful automated representation and processing of noisy, possibly poorly structured knowledge coming from many resources with varyin relevance). Details of the framework are elaborated in a PhD thesis at:http://140.203.154.209/~vit/resources/2010/pubs/phd-thesis.pdfDeveloped under the auspices of Digital Enterprise Research Institute (DERI), National University of Ireland Galway (seehttp://www.deri.ie).
Package: eureka-requests
Eureka RequestsUse eureka to find all possible endpoints and then make requests until it works
starting with the best locationsInstallpip install eureka_requestsUsageimporteureka_requestsdbApi=eureka_requests.RequestsApi("DB-SERVE",_eureka_url,_db_token,)dbApi.post("/testdb",json={"query":"SELECT * FROM USERS"})
Package: eurelis-langchain-solr-vectorstore
Eurelis-Langchain-SolR-VectorStoreThis library allows to use a Solr based vector store with the python version ofLangChainUsageThis library assume you already have a running Solr instance with a configured dense vector field<fieldTypename="knn_vector"class="solr.DenseVectorField"vectorDimension="768"similarityFunction="euclidean"/><fieldname="vector"type="knn_vector"indexed="true"stored="true"/>Be sure to set a vectorDimension value corresponding to what yor embeddings model provide.from langchain.embeddings import HuggingFaceEmbeddings
from eurelis_langchain_solr_vectorstore import Solr

embeddings = HuggingFaceEmbeddings()  # you are free to use any embeddings method allowed by langchain

vector_store = Solr(embeddings)  # with default core configurationYou can also specify data about the solr instance and core to use:vector_store=Solr(embeddings,core_kwargs={'page_content_field':'text_t',# field containing the text content'vector_field':'vector',# field containing the embeddings of the text content'core_name':'langchain',# core name'url_base':'http://localhost:8983/solr'# base url to access solr})# with custom default core configurationIn the code above you have both the allowed core arguments and the default value.MetadataThe Solr based vector store also supports storing and filtering on metadata.Metadata are mapped into Solr using the following convention: metadata_{key}_{type}with
key being the original metadata key, and type is automatically inferred as:ifor integer fieldsdfor float fieldssfor string fieldsbfor boolean fieldsThevector_searchmethod take an optionalwhereparam expecting a dict:dict item key: base name of a metadata fielddict item value: value expected in the metadata fieldExample using the vector store as a retriever:retriever=solr.as_retriever(search_kwargs:{'language':'en',year:2000})DockerA docker compose file is present in the etc/docker folder, use it withdocker compose up -dto launch a solr instance with a core namedlangchainand a 'vector' field with 768 dimensions.