Saravanan666/pypi-org huggingface dataset:
Package: miniworld
Miniworld (formerly gym-miniworld) is currently under development to be made compliant with the standards of the Farama Foundation (https://farama.org/project_standards), and when complete this will be maintained long term.Contents:IntroductionInstallationUsageEnvironmentsDesign and CustomizationTroubleshootingIntroductionMiniWorld is a minimalistic 3D interior environment simulator for reinforcement
learning & robotics research. It can be used to simulate environments with
rooms, doors, hallways and various objects (eg: office and home environments, mazes).
MiniWorld can be seen as a simpler alternative to VizDoom or DMLab. It is written
100% in Python and designed to be easily modified or extended by students.Features:Few dependencies, less likely to break, easy to installEasy to create your own levels, or modify existing onesGood performance, high frame rate, support for multiple processesLightweight, small download, low memory requirementsProvided under a permissive MIT licenseComes with a variety of free 3D models and texturesFully observabletop-down/overhead viewavailableDomain randomizationsupport, for sim-to-real transferAbility todisplay alphanumeric stringson wallsAbility to produce depth maps matching camera images (RGB-D)Limitations:Graphics are basic, nowhere near photorealismPhysics are very basic, not sufficient for robot arms or manipulationPlease use this bibtex if you want to cite this repository in your publications:@misc{gym_miniworld,
  author = {Chevalier-Boisvert, Maxime},
  title = {MiniWorld: Minimalistic 3D Environment for RL & Robotics Research},
  year = {2018},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/maximecb/gym-miniworld}},
}List of publications & submissions using MiniWorld (please open a pull request to add missing entries):Decoupling Exploration and Exploitation for Meta-Reinforcement Learning without Sacrifices(Stanford University, ICML 2021)Rank the Episodes: A Simple Approach for Exploration in Procedurally-Generated Environments(Texas A&M University, Kuai Inc., ICLR 2021)DeepAveragers: Offline Reinforcement Learning by Solving Derived Non-Parametric MDPs(NeurIPS Offline RL Workshop, Oct 2020)Pre-trained Word Embeddings for Goal-conditional Transfer Learning in Reinforcement Learning(University of Antwerp, Jul 2020, ICML 2020 LaReL Workshop)Temporal Abstraction with Interest Functions(Mila, Feb 2020, AAAI 2020)Addressing Sample Complexity in Visual Tasks Using Hindsight Experience Replay and Hallucinatory GANs(Offworld Inc, Georgia Tech, UC Berkeley, ICML 2019 Workshop RL4RealLife)Avoidance Learning Using Observational Reinforcement Learning(Mila, McGill, Sept 2019)Visual Hindsight Experience Replay(Georgia Tech, UC Berkeley, Jan 2019)This simulator was created as part of work done atMila.
Package: miniworldmaker
miniworldmakerminiworldmaker allows you to create 2D mini worlds and games.It is a 2D engine inspired by greenfoot and gamegrid based on pygame.TutorialEnglish|GermanExamplesAngry Birds: This demonstrates the physics engine. It runs somewhat slowly on repl.it, should buy smoothly on modern computers without problems.Kara: Kara PrototypeRPG Framework: Framework for simple RPGs and TextadventuresFeaturesminiworldmaker supports pixel-based games as well as games with
tiles (e.g. Rogue-Likes)Easy creation of animationsMusic and sound effectsIntegrated GUI elements like console for output, toolbar, ...Load and Save to SQLite DatabasesIntegrated Physics-Engine based on PymunkOpen Sourceminiworldmaker is a 2D Engine based on Python 3, pygame and pymunk.ExamplesTop-Down gamesYour browser does not support the video tag.Tile Based RPGsYour browser does not support the video tag.Image Processing.. image:: _images/sunflower6black.png
:width: 100%
:alt: MiniworldmakerPhysicsYour browser does not support the video tag.



  
  Your browser does not support the video tag.Angry BirdsPhysicsYour browser does not support the video tag.NEW: Hex Boardgame:Your browser does not support the video tag.SourceLinksCodeberg|Documentation|PyPi|Cookbook
Package: minixes2
Software to process X-ray Emission Spectroscopy data at APS Sector 20.Note the initial checkin of this software is from the working version used at Sector 20 on March 20, 2019. This code was written by Brian Mattern while he was a graduate student in Gerald Seidler's group at the University of Washington.At this point, the beamline at Sector 20 is using a Pilatus 100k detector and 10 analyzer crystals in a single row.  The spectroscopy group is working on improving the experiment.  They will be adding a Pilatus 2M detector (already purchased and in house) and increase the crystals to a n x m array of analyzers.  This will increase the data throughput of the instrument by allowing for more simultaneous measurements of the energy spectrum.
The original source code has been modified by the John Hammonds (JPHammonds@anl.gov) in the Scientific Software Engineering and Data Management Group in the X-Ray Science Division at the Advanced Photon Source at Argonne National Laboratory.  These changes are to accomodate the changes mentioned above to the Crystal Analyzer and Detector.  The file CHANGES.md captures information about major changes to the code from the original version.
Package: minixsv
minixsv is a lightweight XML schema validator written in “pure” Python.Currently a subset of the XML schema standard is supported.minixsv is based on genxmlif, a generic XML interface class,
which currently supports minidom, elementtree or 4DOM/pyXML as XML parser
Other parsers can be adapted by implementing an appropriate derived interface class.minixsv provides a simple programming interface (API) for validation of schema
and XML input files. Parser or validation errors will raise exceptions.After successful validation minixsv provides the input XML tree with the following changes:Whitespaces inside strings are automatically normalized/collapsed as specified in the XML schema file.Default/Fixed attributes are automatically inserted if not specified in the input file.The “post validation” XML tree can be accessed using genxmlif or the contained original interface (minidom, elementtree or 4DOM/pyXML).
Package: mini-yahoo-finance
Minimal Yahoo! Finance APIA minimal library for downloading stock data from Yahoo! Finance into a Pandas DataFrame.Since I am using this functionality for some time now, I thought I might as well write up this code nicely into a library and make it available.Examplefrommini_yahoo_financeimportget_stock_dfdf=get_stock_df('ADS.DE','01-01-2018',end_date='31-01-2018',interval='1d',max_retries=3)UsageAccepted values forintervalare:1d(default)1wk1moIf noend_dateis provided, the current date will be used.Installationgit clone https://github.com/lucaionescu/mini-yahoo-finance-api.git
cd mini-yahoo-finance-api/
pip install .RequirementsBeautifulSoupPandasRequestsPossible future to-dosremove BeautifulSoup dependencybulk download of multiple stocks using multithreadingSuggestions or problems? Don't hesitate to contact me or open a pull request!
Package: mini-youtube-player
mini-youtube-playerSearch and play videos on youtube in cliMain features:Search for Videos or Playlists on youtubeView the search resultsPlay a video or only listen to audioView a history of recently played videosDownload audio or video file from search resultsThat's it. mini-youtube-player is not intended to have many features.Instead it is intended to be simple and just work. (hopefully)mini-youtube-player useshttps://github.com/alexmercerind/youtube-search-python-- thanks for the great work!Have fun.
Don't do stuff you are not allowed to do.Installation$pipinstallmini-youtube-playerUsage example$mini-youtube-playerRelease History1.0.3First version published.MetaDistributed under the MIT license.
Package: minj
versão em português abaixoMinimalist journalingThis is a minimalist CLI journal. It is intended to log daily activities and evaluations of all kinds of sorts - well-being, physical, mental, energy levels and so on.InstallingSoonUsageTo get help:minj -hminj sleep 22:30 6:30to log your sleep and wake up time, respectively.minj metricsto log the metrics that you're tracking.References:Peter Lyons on career adviceJeff Atwood (StackOverflow co-founder) on writingjrnl - Python JournalDiário minimalistaEste é um diário minimalista para linha de comando (CLI).Vou escrever depois melhor a motivação. O objetivo é criar um log das atividades diárias realizadas e como você se sente, pra quem sabe extrair alguma relação destes dados. Extraindo ou não, o fato de você registrar esses logs já dá uma clareada na mente sobre você mesmo. Leia mais em Journal Smarter.Vou começar registrando só coisas relacionadas ao sono e a qualidade do sono no dia seguinte, que é sobre o que tô lendo agora - o maravilhoso livro Why We Sleep de Matthew Walker. A ideia é ir incrementando pra registrar todas as atividades: exercício, alimentação, meditação, estudos, etc.UsoVocê pode ler as opções utilizandominj -hminj sleep 22:30 6:30registra o horário que você dormiu (22:30) e que acordou (6:30), respectivamente.minj metricsregistra as métricas que você está medindo atualmente.Referências
Package: minjob
Descriptionminjobis a simple, purely Python library which allows to monitor Python threads and processes. It restarts the processes it monitors when a
fatal exception occurs and can smoothly terminate them.This small library provides a simple way for dealing with fatal
exceptions when running simple multi-thread/multi-process applications
with high availability requirements such as market trading bots.By default the library will print the logs of the failed jobs at{HOME}/.minjob.log.Installation and UsageInstall the library within your favorite virtual environment or locally using:pipinstallminjobA simple usage of the library for adding a monitored process and
thread goes like this:fromminjob.jobsimportJobManagerdefmy_thread_func():do_some_work()defmy_process_func():do_other_work()manager=JobManager(name="MyManager")manager.add_process("MyProcess",target=my_process_func,daemonize=True)manager.add_thread("MyThread",target=my_thread_func,daemonize=True)# start all monitored jobsmanager.start_all()# stop all jobsmanager.stop_all()
Package: minka-johann-haselberger
AboutMinka is ment to be a middleware between your optimization problem and a modular set of supporting tools to:automatically perform hyperparameter optimizationstore the results, parameter sets and custom datacompare different training runsvisualize the results and training processesThe aim of the project is to provide a simple as possible interface without the need to change your existing code.One line to change it allCould it be easier than just adding one line?minka(yourOptimizationTask,'configuration.json').opt(numberOfRuns)Architecture overviewUsageInstallation!pip install --upgrade PyYAML==4.2b4 optuna sacred python-telegram-bot dnspython loguru wandb pymongoPreparationIn order to store the data, a mongoDB is required. You can host your own free one here:https://cloud.mongodb.comIf you want to use the w&b interface, an account is needed. Create one here:https://app.wandb.aiDefine your optimization problemMinka uses a very simple combination of a configuration json file and the actual optimization task, represented as a single class.optimization classoptimization template:classyourOptimizationTask:def__init__(self):passdefprepare(self):passdefrun(self,config):x=config['x']result=(x-2)**2evalMetrics={'error':result}logArrays={'someValues':[1,2,3,4]}returnresult,evalMetrics,logArraysdefcleanup(self):passparameter configurationcontent of the configuration.json file:{"comment":"parameter types: fix, categorical, discrete_uniform, int, loguniform, uniform","parameters":{"batchSize":{"type":"fix","values":256},"epochs":{"type":"fix","values":75},"x":{"type":"categorical","values":[11,22,26]}}}Screenshots
Package: minke
Minke: The Burst MDC FactoryMinke is a Python package to produce Mock Data Challenge data sets for LIGO interferometers.Free software: ISC licenseDocumentation:https://daniel-williams.docs.ligo.org/minke/FeaturesProduces burst MDCs with Gaussian, SineGaussian, and White Noise Burst ad-hoc waveformsProduces ringdown waveforms for MDCsProduces numerical relativity burst MDCs for supernovaeProduces numerical relativity burst MDCs for long duration searchesProduces GWF frame files for MDCsProduces GravEn-format log files for MDCsProduces hardware-injection ready data filesProduces SimBurstTable XML files for MDCsHistory1.1.9 (2021-05-04)Corrects behaviour of numerical relativity waveforms in geometric units by incorporating the extraction radius.1.1.6Provisional Python 3.6 and 3.7 support.1.1.5Addition of provisional support for NR hyperbolic waveformsRemoval of glue.segments dependency1.1.4Bug fix in frame creation for supernovae1.1.3Minor fixes to the documentation of the code.1.1.2Minor bug-fixes to improve Hardware injection support1.1.1 (2018-03-27)Made a change to the package meta data to allow upload to PYPI.1.1.0 (2018-03-27)“Luce Bay”Added full support for hardware injection productionAdded Yakunin Supernova waveform familyAdded Ringdow waveform supportAdded support for all lscsoft table formatsAdded support for editing xml filesAdded support for String Cusp waveforms1.0.1 (2017-01-23)Added provisional support for hardware injection production1.0.0 (2016-09-14)The Anniversary Update.ER10 and O2 ReadinessFully capable of producing supernova injectionsFully capable of producing lalsimulation-burst waveformsExtensible interface for parameter distributions0.1.0 (2016-3-14)First release on PyPI.
Package: minkf
minkf - minimal Kalman filter in PythonKalman filter/smoother, nothing more. A minimal implementation with onlynumpydependency. No fancy classes, just simple functions.Estimates the states of the systemCalculates also the likelihood of the data, in case one wants to do some hyperparameter tuning. One can also sample from the posterior distribution of the states.Installationpip install minkfExampleThe example does some plots viamatplotlib, which is not listed as a dependency in order to keep them minimal. Thus, installmatplotlibon top ofminkfto get the plots working.The example is about fitting an existing batch of data. For on-line Kalman filtering, check theminkf.kf_predictandminkf.kf_updatefunctions in the package.For more examples asjupyternotebooks, check thedemosfolder.Reconstructing random 1d dataThe first example just generates some 1d random walk data and reconstructs it with Kalman filter/smoother. The forward and observation models are just identities. The user can either give the model and error covariance matrices as lists, which enable using different values for each time step. If the matrices are given as constant numpy arrays, the same matrices are used for every time step.importnumpyasnpimportminkfaskfimportmatplotlib.pyplotasplty=np.cumsum(np.random.standard_normal(100))x0=np.array([0.0])Cest0=1*np.array([[1.0]])M=np.array([[1.0]])K=np.array([[1.0]])Q=0.1*np.array([[1.0]])R=0.1*np.array([[1.0]])res=kf.run_filter(y,x0,Cest0,M,K,Q,R,likelihood=True)res_smo=kf.run_smoother(y,x0,Cest0,M,K,Q,R)plt.figure()plt.plot(y,'bo',ms=5)plt.plot(res['x'],'k-')plt.plot(res_smo['x'],'r-')plt.grid(True)plt.show()Result is a dict that contains the estimated states and the filtering/smoothing covariances. Iflikelihood=Trueis chosen in the filter, the result structure also contains the log-likelihood of the data given the model. This can be useful in, e.g., estimating hyperparameters: one could run the Kalman filter repeatedly via an optimizer or MCMC sampler, for instance.res['loglike']297.0302824838724Sampling from the posterior of the states given all the data can be done via thesamplefunction. Sampling needs the Kalman filter results and the dynamics model matrix and model error covariance.samps=kf.sample(res,M,Q,nsamples=10)plt.figure()plt.plot(np.array(samps).T,'r-',alpha=0.2)plt.plot(y,'bo',ms=2)plt.grid(True)plt.show()Missing observationsIf any element of the observation vector isnp.nan, the observation is considered missing. Below is the above simple example with some missing observations in the middle.y_missing=y.copy()y_missing[40:60]=np.nanres_missing=kf.run_filter(y_missing,x0,Cest0,M,K,Q,R,likelihood=True)res_smo_missing=kf.run_smoother(y_missing,x0,Cest0,M,K,Q,R)plt.figure()plt.plot(y_missing,'bo',ms=5)plt.plot(res_missing['x'],'k-')plt.plot(res_smo_missing['x'],'r-')plt.grid(True)plt.show()samps_missing=kf.sample(res_missing,M,Q,nsamples=10)plt.figure()plt.plot(np.array(samps_missing).T,'r-',alpha=0.2)plt.plot(y_missing,'bo',ms=2)plt.grid(True)plt.show()
Package: minkit
This package provides tools to fit probability density functions (PDFs) to both unbinned and binned data, using different minimizers (likeMinuit).
The MinKit package appears as an alternative to existing minimization packages, likeRooFit.
The idea is to provide a friendly pure python API to do minimization and calculations with PDFs.
It has support for both CPU and GPU backends, being very easy for the user to change from one to the other.
PDFs are implemented in C++, OpenCL and CUDA, allowing a fast evaluation of the functions.The package is built on top of thenumpyandiminuitpackages.
The interface with CUDA and OpenCL is handled usingreikna, which is itself an API forPyCUDAandPyOpenCL.Basic exampleClasses meant for the user are imported directly from the main moduleimportminkitx=minkit.Parameter('x',bounds=(-10,+10))c=minkit.Parameter('c',0.)s=minkit.Parameter('s',1.)g=minkit.Gaussian('Gaussian',x,c,s)data=g.generate(10000)These lines define the parameters used by a Gaussian function, and a data set is generated
following this distribution.
The sample can be easily fitted calling:withminkit.unbinned_minimizer('uml',g,data)asminimizer:r=minimizer.migrad()In this caseminimizeris aMinuitinstance, since by defaultMinuitis used to do the minimization.
The stringumlspecifies the type of figure to minimize (FCN), unbinned-maximum likelihood, in this case.The compilation of C++ sources is completely system dependent (Linux, MacOS, Windows), and it also depends on the way python
has been installed.
The PDFs in this package need the C++ standard from 2011.
Depending on the system, functions might need to be compiled with extra flags that are not used by default indistutils.
If you get errors of the type:relocationR_X86_64_PC32againstundefinedsymbolsuggesting to use-fPICoption (when the system is usinggccto compile C code) orerror:‘erf’isnotamemberof‘std’more likely it is needed to specify the flags to use.
In order to do so, simply execute your script setting the value of the environmental variableCFLAGSaccordingly:CFLAGS="-fPIC -std=c++11"pythonscript.pyFast installation:This package is available onPyPi, so simply typepipinstallminkitto install the package in your current python environment.
To use thelatest development version, clone the repository and install withpip:gitclonehttps://github.com/mramospe/minkit.gitpipinstallminkitIn order to profit from certain features of the package, like numerical integration, it is necessary
that the system has theGSLlibraries visible to the compiler.
To install them on Linux, you can simply runsudoapt-getinstalllibgsl-devDepending on the system, you might need to set also the necessary environment variables
specifying the path to the include and libraries directory, likeexportCFLAGS="$CFLAGS-I/usr/include -L/usr/lib/x86_64-linux-gnu"
Package: minknow-api
Python API client for MinKNOWThis package provides a Python client to access theMinKNOW APIs. You will need a
compatible version of MinKNOW already installed to make use of this project.To check for compatibility, look at the version ofMinKNOW Core. The first two components of the
MinKNOW Core version should match the first two components of theminknow_apiversion. For
example,minknow_api5.4.0 is compatible with any 5.4.x version of MinKNOW Core (which is part of
the 22.12 release of MinKNOW).See themain README in the git repositoryfor more information about the MinKNOW API.UsingThe recommended way to get it is from PyPI using pip, but it can also be built from source (seeBUILD.mdin the top level of the git repository).# Install minknow_api>pipinstallminknow_api# Verify API is installed correctly:>python-mminknow_api.examples.list_sequencing_positions--hostlocalhost# Possible output if running MinKNOW locally:#   Available sequencing positions on localhost:9502:#   MN12345: running#     secure: 8000The package contains plenty of documentation in its docstrings, although for an overview of the
MinKNOW APIs themselves you may prefer to read theAPI description files- see below
for further discussion of these files. There are alsoexamplesin theminknow_api.examplessubmodule that show how to perform some common tasks.Licence and Copyright© 2023 Oxford Nanopore Technologies PLC.API Specifications for MinKNOW is distributed under the Terms and Conditions of the Nanopore
Community.TroubleshootingBad metadata keyIf you see the following error when connecting to thelocalmachine:grpc._channel._InactiveRpcError: <_InactiveRpcError of RPC that terminated with:
        status = StatusCode.UNAUTHENTICATED
        details = "Bad metadata key"you can try setting theMINKNOW_API_USE_LOCAL_TOKENenvironment variable to1. Note that you
will need to have MinKNOW's local guest mode enabled for this to work (it is enabled by default, but
the setting can be changed via Mooneye).Invalid local auth tokenIf you see the following error when connecting to aremotemachine:grpc._channel._InactiveRpcError: <_InactiveRpcError of RPC that terminated with:
        status = StatusCode.UNAUTHENTICATED
        details = "Invalid local auth token"you can try setting theMINKNOW_API_USE_LOCAL_TOKENenvironment variable to0.MissingMinknowSSlCertErrorIf you get aMissingMinknowSSlCertErrorexception, try setting theMINKNOW_TRUSTED_CAenvironment variable. This should be the path to theconf/rpc-certs/ca.crtfile found in a MinKNOW
installation. You should use a copy of the file from the same version of MinKNOW as the one you are
attempting to connect to.
Package: minlpe
MinLpEAdaptive sampling based on the minimization of approximation error Lp norm. MaxLpE is a fast adaptive sampling algorithm with accuracy comparable with the best known adaptive sampling methods: TEAD, LIP, MIPT, EIGF, MASA, SFVCT. Its features include smapling time control and parallel (batch) point generation. The norm parameter p regulates sampling, inclining it either towards local exploitation or, conversely, global exploration. Small Lp norm is achieved by reducing the function approximation error and the size of the region with large variation after adding a new sampling point. This solution is similar to kriging in terms of the choice between local exploitation and global exploration. The difference is in error estimation which depends on the values of the function in sampling points in contrast to homoscedastic variance estimate of kriging.Installationpip install --upgrade minlpeUsageSee file examples.pyIf you like the software, acknowledge it using the references below:S.A.Guda, A.S.Algasov, V.I.Kolesnikov, A.V.Soldatov, V.V.Ilicheva Fast adaptive sampling with operation time control // Journal of Computational Science, in press.