Saravanan666/pypi-org huggingface dataset:
Package: eQuimage
eQuimage is a python tool to postprocess astronomical images from Unistellar telescopesAuthor: Yann-Michel Niquet (https://astro.ymniquet.fr)InstallationeQuimage is developed in Python 3 with a GTK3 graphical interface. Python 3 and the GTK3 library are available in all Linux distributions; On Windows, followhttps://www.gtk.org/docs/installations/windows/for GTK3. To install the latest version of eQuimage, open a linux terminal/windows command prompt and run:pip install --user eQuimagepip will automatically download eQuimage and the missing python modules if necessary (matplotlib, etc...). You can then launch eQuimage by typing:eQuimagein this same terminal. You can also create a link to eQuimage from your desktop; an icon is distributed for this purpose with the python package.UsageThis code has no claim and only offers elementary operations compared to other more advanced image processing or astrophotography software (GIMP, SIRIL, PixInsight, etc...). Among its specific features, eQuimage canhighlight the pixels "blackened" or saturated by the treatments (in each R/G/B channel),leave the frame of the Unistellar images unprocessed (option only implemented to date for the eQuinox 1 telescope, but feel free to contribute or send me sample images from other telescopes !),compare different treatments to help choose the best options,keep track (in a log file) of all operations applied to a given image.There is no documentation yet, but you should find your way around easily if you have used image processing software before. The python code itself is documented in English.Known bugsOn windows, the imageio/freeimage plugin can not read png's with accents (and likely other special characters) in the file name.
Package: equine
Establishing Quantified Uncertainty in Neural NetworksUsageDeep neural networks (DNNs) for supervised labeling problems are known to
produce accurate results on a wide variety of learning tasks. However, when
accuracy is the only objective, DNNs frequently make over-confident predictions,
and they also always make a label prediction regardless of whether or not the
test data belongs to any known labels.EQUINE was created to simplify two kinds of uncertainty quantification for supervised labeling problems:Calibrated probabilities for each predicted labelAn in-distribution score, indicating whether any of the model's known labels should be trusted.Dive into ourdocumentation examplesto get started. Additionally, we provide acompanion web application.InstallationUsers are recommended to install a virtual environment such as Anaconda, as is also recommended
in thepytorch installation. EQUINE has relatively
few dependencies beyond torch.pip install equineUsers interested in contributing should refer toCONTRIBUTING.mdfor details.DesignEQUINE extends pytorch'snn.Moduleinterface using apredictmethod that returns both
the class predictions and the extra OOD scores.DisclaimerDISTRIBUTION STATEMENT A. Approved for public release. Distribution is unlimited.© 2024 MASSACHUSETTS INSTITUTE OF TECHNOLOGYSubject to FAR 52.227-11 – Patent Rights – Ownership by the Contractor (May 2014)SPDX-License-Identifier: MITThis material is based upon work supported by the Under Secretary of Defense for Research and Engineering under Air Force Contract No. FA8702-15-D-0001. Any opinions, findings, conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the Under Secretary of Defense for Research and Engineering.The software/firmware is provided to you on an As-Is basis.
Package: equinor-libres
libreslibresis part of theERTproject:Ensemble based Reservoir Tool. It is now available in PyPI:$pipinstallequinor-libresor, for the latest development version (requires GCC/clang andPython.h):$pipinstallgit+https://github.com/equinor/libres.git@masterDevelopmentlibresis meant to be installed usingsetup.py, directly or usingpip install ./. TheCMakeLists.txtexists, but is used bysetup.pyto generate
thelibresC library and by Github Actions to run C tests.libresrequires a recent version ofpip- hence you are advised to upgrade yourpipinstallation with$pipinstall--upgradepipIf yourpipversion is too old the installation oflibreswill fail, and the error messages will be incomprehensible.BuildingUse the following commands to start developing from a clean virtualenv$ pip install -r requirements.txt
$ python setup.py developAlternatively,pip install -e .will also setuplibresfor development, but
it will be more difficult to recompile the C library.scikit-buildis used
for compiling the C library. It creates a directory named_skbuildwhich is
reused upon future invocations of eitherpython setup.py develop, orpython setup.py build_ext. The latter only rebuilds the C library. In some cases this
directory must be removed in order for compilation to succeed.The C library files get installed intopython/res/.libs, which is where theresmodule will look for them.Testing Python codeInstall the required testing packages and run tests.$ pip install -r test_requirements.txt
$ pytestTesting C codeInstalleclusing CMake as a C library. Then:$mkdirbuild
$cdbuild
$cmake..-DBUILD_TESTS=ON
$cmake--build.
$ctest--output-on-failureConfigurationThesite_configfileAs part of the installation processlibreswill install a file calledsite-configinshare/ert/site-config; when ert starts this file will be
loaded before the users personal config file. For more extensive use ofertit
might be benefical to customize thesite-configfile to your personal site.To customize, you need to set the environment variableERT_SITE_CONFIGto
point to an alternative file that will be used.6.2 Forward modelslibrescontains basic functionality for forward models to run the reservoir
simulators Eclipse/flow and the geomodelling program RMS. Exactly how these
programs depend on the setup on your site and you must make some modifications
to two files installed withlibres:6.2.1. Eclipse/flow configurationIn the Python distribution installed bylibresthere is a fileres/fm/ecl/ecl_config.ymlwhich is used to configure the eclipse/flow versions
are available at the location. You can provide an alternative configuration file
by setting the environment variableECL_SITE_CONFIG.6.2.2. RMS configurationIn the Python distribution installed bylibresthere is a file:res/fm/rms/rms_config.ymlwhich contains some site specific RMS configuration.
You should provide an alternative file with your local path to thermswrapper
script supplied byRoxarby setting the environment variableRMS_SITE_CONFIGto point to the alternative file.
Package: equinox
EquinoxEquinox is your one-stopJAXlibrary, for everything you need that isn't already in core JAX:neural networks (or more generally any model), with easy-to-use PyTorch-like syntax;filtered APIs for transformations;useful PyTree manipulation routines;advanced features like runtime errors;and best of all, Equinox isn't a framework: everything you write in Equinox is compatible with anything else in JAX or the ecosystem.If you're completely new to JAX, then start with thisCNN on MNIST example.Coming fromFlaxorHaiku? The main difference is that Equinox (a) offers a lot of advanced features not found in these libraries, like PyTree manipulation or runtime errors; (b) has a simpler way of building models: they're just PyTrees, so they can pass across JIT/grad/etc. boundaries smoothly.InstallationpipinstallequinoxRequires Python 3.9+ and JAX 0.4.13+.DocumentationAvailable athttps://docs.kidger.site/equinox.Quick exampleModels are defined using PyTorch-like syntax:importequinoxaseqximportjaxclassLinear(eqx.Module):weight:jax.Arraybias:jax.Arraydef__init__(self,in_size,out_size,key):wkey,bkey=jax.random.split(key)self.weight=jax.random.normal(wkey,(out_size,in_size))self.bias=jax.random.normal(bkey,(out_size,))def__call__(self,x):returnself.weight@x+self.biasand fully compatible with normal JAX operations:@jax.jit@jax.graddefloss_fn(model,x,y):pred_y=jax.vmap(model)(x)returnjax.numpy.mean((y-pred_y)**2)batch_size,in_size,out_size=32,2,3model=Linear(in_size,out_size,key=jax.random.PRNGKey(0))x=jax.numpy.zeros((batch_size,in_size))y=jax.numpy.zeros((batch_size,out_size))grads=loss_fn(model,x,y)Finally, there's no magic behind the scenes. Alleqx.Moduledoes is register your class as a PyTree. From that point onwards, JAX already knows how to work with PyTrees.CitationIf you found this library to be useful in academic work, then please cite: (arXiv link)@article{kidger2021equinox,author={Patrick Kidger and Cristian Garcia},title={{E}quinox: neural networks in {JAX} via callable {P}y{T}rees and filtered transformations},year={2021},journal={Differentiable Programming workshop at Neural Information Processing Systems 2021}}(Also consider starring the project on GitHub.)See also: other libraries in the JAX ecosystemjaxtyping: type annotations for shape/dtype of arrays.Optax: first-order gradient (SGD, Adam, ...) optimisers.Diffrax: numerical differential equation solvers.Optimistix: root finding, minimisation, fixed points, and least squares.Lineax: linear solvers.BlackJAX: probabilistic+Bayesian sampling.Orbax: checkpointing (async/multi-host/multi-device).sympy2jax: SymPy<->JAX conversion; train symbolic expressions via gradient descent.Eqxvision: computer vision models.Levanter: scalable+reliable training of foundation models (e.g. LLMs).PySR: symbolic regression. (Non-JAX honourable mention!)DisclaimerEquinox is maintained by Patrick Kidger at Google X, but this is not an official Google product.
Package: equinox-gould29
EQUINOXEquinox is a powerful and scalable Python library for calculating inter-annotator agreement scores for a variety of Natural Language Processing and Machine Learning tasks.For example:Fleiss's Kappa: A statistical measure for assessing the reliability of agreement between a fixed number of raters when assigning categorical ratings to a number of items or classifying items.Many advanced ML tasks require annotating enormous amounts of data, which is a tedious and time-consuming task. Add on the time required to wrangle the data and compute inter-annotator agreement scores, andpoof, weeks have gone by. We aim to answer the call for quicker annotation metrics Whether you are an academic, ML Engineer, or Citizen Data Scientist, Equinos is straightforward to install and our goal is to allow you to get to your NLP insights faster.More funcionality is currently being built, and will be deployed upon completion. Stay tuned!InstallationEquinox can easily be installed viapip:pip install equinox-gould29How to Use EquinoxEquinox is very simple to use. See our documentation for more information. Below is an example to compute Fleiss's Kappa for > 2 annotators.#Import
from equinox import score

#Define Input
entities = ["yes", "no"]
num_annotators = 10
df = pd.read_csv("annotated_data.csv") #See below

k = score.fleiss_kappa(entities, num_annotators, df)
## 0.53Where:entitiesA list of the names of entities annotated. These entity names must match the column names indf.num_annotators: The number of annotators in the dataset.df: Pandas DataFrame consiting of the number of annotations per entity (columns) for a finite number of documents (rows):Interpretting Fleiss's Kappa CoefficientsDependenciesEquinox requires the following:PandasRunning TestsTests are written in thetestsdirectory and processed usingPyTest <https://docs.pytest.org/en/latest/>__.Python VersionEquinox supportsPython 3.6+ <https://python3statement.org/>__ and, due to the use of unicode variable names/identifiers, is not compatible with Python 2.x. Given the small dependencies, Equinox may work on older versions of Python but this is beyond the scope of our support and we strongly recommend that you upgrade to the most recent version of Python.
Package: equinox-server
equinoxis a Python / Django powered portfolio management platform that allows the collection and reporting of project finance risk and sustainability characteristicsArchitectureAt the core of equinox are a number of data models that capture information about the different entities and concepts involved in Sustainable Finance. These data models follow a logical pattern that is independent of any of the reference standards or eventual applications that are being implemented.Functionality is delivered via a number of apps that process user inputs and portfolio data and deliver analyses and reportsData LayerThe data layer can be segmented into two major categories: The Physical Layer that holds information about physical aspects of assets, activities etc. and the “socioeconomic” layer that holds information about entities, economic and financial aspects etc.Physical LayerProject is the core object. It belongs to a Project CategoryOne or More Assets are major real items linked to the Project.Primary Effect is the GHG impact of a Project ActivitySecondary Effect is the GHG impact of a Project ActivityProject Activity is a specific Sustainability impact (eg GHG reduction) of a ProjectSocioeconomic LayerProject Company is a Legal Entity that finances a ProjectContractors are Entities that are involved in delivering under contract to the Project CompanyOperators are Entities that are involved in operating under contract to the Project CompanySponsors are Entities that are involved in commissioning, guaranteeing or providing equity to the Project CompanyStakeholders are other entities that are impacted or impacting by the Project CompanyRevenue focuses specifically on the business model of a Project CompanyA Loan is a borrowing made by a Project CompanySwap is an example of additional contract by the Project CompanyScorecard collects relevant data to support the risk analysis of a Project CompanyApplication LayerThe application layer help the user extract useful information from the database and perform the required analyses and reportsAsset ManagerRisk AnalysisResults Explorer
Package: equip
equip is a small library that helps with Python bytecode instrumentation. Its API
is designed to be small and flexible to enable a wide range of possible instrumentations.The instrumentation is designed around the injection of bytecode inside the
bytecode of the program to be instrumented. However, the developer does not need to know
anything about the Python bytecode.The following example shows how to write a simple instrumentation tool that will print all
method called in the program, along with its arguments:import sys
import equip
from equip import Instrumentation, MethodVisitor, SimpleRewriter

BEFORE_CODE = """
print ">> START"
print "[CALL] {file_name}::{method_name}:{lineno}", {arguments}
print "<< END"
"""

class MethodInstr(MethodVisitor):
  def __init__(self):
    MethodVisitor.__init__(self)

  def visit(self, meth_decl):
    rewriter = SimpleRewriter(meth_decl)
    rewriter.insert_before(BEFORE_CODE)

instr_visitor = MethodInstr()
instr = Instrumentation(sys.argv[1])
if not instr.prepare_program():
  return
instr.apply(instr_visitor, rewrite=True)This program requires the path to the program to instrument, and will compile the source
to generate the bytecode to instrument. All bytecode will be loaded into its representation,
and theMethodInstrvisitor will be called on all method declarations.When a change is required (i.e., the code actually needs to be instrumented), theInstrumentationwill overwrite thepycfile.Running the instrumented program afterwards does not require anything but executing it as you
would usually do. If the injected code has external dependencies, you can simply modify thePYTHONPATHto point to the required modules.
Package: equipy
EquiPyis a Python package implementing sequential fairness on the predicted outputs of Machine Learning models, when dealing with multiple sensitive attributes. This post-processing method progressively achieve fairness accross a set of sensitive features by leveraging multi-marginal Wasserstein barycenters, which extends the standard notion of Strong Demographic Parity to the case with multiple sensitive characteristics. This approach seamlessly extends
to approximate fairness, enveloping a framework accommodating the trade-off between performance and unfairness.The project was started in 2023 by François Hu, Philipp Ratz, Suzie Grondin, Agathe Fernandes Machado and Arthur Charpentier, following the release of this paper “A Sequentially Fair Mechanism for Multiple Sensitive Attributes” (https://arxiv.org/pdf/2309.06627.pdf), written by François Hu, Philipp Ratz and Arthur Charpentier.InstallationDependenciesEquiPy requires:Numpy (>= 1.17.3)Scipy (>= 1.5.0)Scikit-learn (== 1.3.0)Matplotlib (== 3.7.2)Pandas (== 2.0.3)Statsmodels (== 0.14.0)Seaborn (== 0.12.2)POT (==0.9.1)User installationTo install EquiPy, usepip:pip install equipyVisualizationThis package contains the modulegraphswhich allows visualization of the resulting sequential fairness applied to a response variable.Help and SupportCommunicationMailing list:hu.faugon@gmail.comsuzie.grondin@gmail.comratz.philipp@courrier.uqam.cafernandes_machado.agathe@courrier.uqam.caarthur.charpentier@gmail.com
Package: equitable-coloring
Equitable coloring fornetworkXgraphs.FromWikipedia:In graph theory [..] an equitable coloring is an assignment of colors to the vertices of an undirected graph, in such a way thatNo two adjacent vertices have the same color, andThe numbers of vertices in any two color classes differ by at most one.Kierstead et. al.have provided a fast polynomial time algorithm for uncovering an equitable coloring usingr + 1colors for a graph with maximum degreer.
This package is an implementation of the algorithm for networkX graphs.Free software: MIT licenseInstallationpip install equitable-coloringUsageTo useequitable-coloring:>>> import networkx as nx
>>> from equitable_coloring import equitable_color
>>> from equitable_coloring.utils import is_equitable
>>> G = nx.cycle_graph(4)
>>> d = equitable_color(G, num_colors=3)
>>> is_equitable(G, d)
TrueDocumentationhttps://equitable-coloring.readthedocs.io/DevelopmentTo run the all tests run:pip install pytest-cov  # Needed the first time.
python setup.py testOr, you can usetox.Changelog0.1.2 (2018-06-30)Update README and usage instructions.0.1.1 (2018-06-30)Initial version with tests.0.1.0 (2018-06-11)First commit.
Package: equitorium
EquityAnalyzerTo find investment opportunity and trading signal through fundamental analysis and technical analysis in Bursa Malaysia (KLSE)Issue TrackerFundamental AnalysisTo collect financial statement for both Annual and Quarter frequencyTo generate the overview of company performance using statistical score:Altman Z Score (Simple Credit Strength test)Ohlson O Score (Extended from Z-Score, Likelihood to default in 2 years)Beneish M Score (8) - Profit ManipulationPiotroski F Score (Determine strength of a firm's financial position, avoid value traps)EBIT / EV (Alternative to PE ratio, take into account of debt)Net Cash (Net cash position of a company)Market Capitalization (Market value of company outstanding shares)52W Range vs Current Price (Position of share price over last 52 weeks)To collect the commodity price and foreign exchangeRubberwoodResinGoldLumberUSD/MYRBaltic dryCrude oilPalm oilLumberSugarPoultryCornSteelFearixTo update the existing data file rather than replacing itTechnical AnalysisTo collect historical data from yahoo APICreate and define technical indicatorModellingClassification - Trading signal (Buy or sell?)Regression - Entry Price / Stop loss (Buy/Sell at what price?)Natural Language Processing (NLP) - TBCFootnote preparation / Remarks
            - To collect and summarize information from quarter report / analyst reportNews / Forum
            - Sentiment AnalysisUser InterfaceTable (Statement, historical share price)Graph (Historical Share price and the technical indicator)Trading signal (Search and filter function)
Package: equitweet
equitweetfrom equitweet import init_equitweet

eqt = init_equitweet(config.TWITTER_CONFIG)

eqt.search_tweets_for_ticker('A')

eqt.batch_search_tweets_for_tickers(['A', 'B'])

eqt.write_tweets_to_file(filename='tweets.csv')Next StepsDB integrationBacktesting, NLP, EDA examplesPandas supportLuigi supportPlotly.js Dash exampleLicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.
Package: equity-jenga-api
py-equity-jenga-api.DocumentationHow to Install# In terminal do:pipinstallequity-jenga-apiBuilding from Source for Developers$gitclonehttps://github.com/TralahM/py-equity-jenga-api.git$cdpy-equity-jenga-apiSupported Pesa Link Patner BanksContributingSee the Contributing FileSee the Pull Request FileSupportLICENCERead the license hereSelf-Promotion
Package: eq-utils
=====
eq-utils version 0.0.7'eq-utils' is a Django reusable app to help you make models easier.Quick startpip install eq-utils==Add "eq_utils" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [
'eq_utils',
]Import the module like this:from eq_utils.base_model import ModelAddressBase (or whatever you need)
or
from eq_utils.base_model import AbstractNameModel (or whatever you need)And that's all.Usage:ModelosInherit the ModelAddressBase in the model.Inherit the AbstractNameModel in the model.AdminsInherit the AdminHide in the admin.Inherit the EditOnlyTabularInline in the admin.Inherit the BaseReadOnlyAdmin in the admin.FiltrosInherit the EqAutofilter in the filter.Recuperacion de datosInherit the DataRecover in the class to recover data.
Package: eqversion
The purpose ofEQVersionis to remove the change redundancy in the project version in two places, in thepyproject.tomland in the__init__.pyof the main package.EQVersionis especially for those who work withPoetry.Using:In a project usingPoetryand an active virtual environment, addEQVersionas a development dependency:$poetryaddeqversion--devNow simply run the command below for the versions to be matched:$eqversionSpecifying a package:By default,EQVersiontakes the name of the main package viapyproject.toml, in the keyname, but it may happen that the name of the main package is not the same as inpyproject.toml. If this happens, the–packageoption should be used to specify the main package:$eqversion--package=<PACKAGEMAINNAME>Using with tests:You must callEQVersionbefore performing your tests.Example oftox.inifile:[tox]isolated_build=True[testenv]setenv=PYTHONPATH={toxinidir}deps=poetrycommands=pip install --upgrade pippoetry installpoetry run eqversion;   Or use the named option:;   poetry run eqversion --package=<PACKAGE MAIN NAME>poetry run pytest --basetemp={envtmpdir}LinksAuthors:https://github.com/snakypy/eqversion/blob/master/AUTHORS.rstCode:https://github.com/snakypy/eqversionDocumentation:https://github.com/snakypy/eqversion/blob/master/README.rstReleases:https://pypi.org/project/eqversion/#historyIssue tracker:https://github.com/snakypy/eqversion/issuesDonationIf you liked my work, buy me a coffee <3LicenseThe gem is available as open source under the terms of theMIT License©