Saravanan666/pypi-org huggingface dataset:
Package: mini-api
mini-apiPython minimalistic HTTP(S) serverSome small long running utilities don't need fancy webframeworks to offer
simple APIs over HTTP without any additional dependency that this module.It spawns a thread to process incoming requests.importmini_apiserver=mini_api.Server(server_address=('localhost',8888))@server.route('aaa')defroute(args):return200,'All good'server.start()...server.stop()
Package: miniasync
miniasyncminiasyncis a small library build on top ofasyncioto faciliate running small portions of asynchronous code in an otherwise synchronous application.A typical use case is an application which is build as a synchronous application, but at some point needs to make an http request to two different web services and await the results before continuing. In synchronous Python you’d have to do each request in turn -miniasyncmakes it easier to run both requests in parallel without having to writeasyncioboilerplate code.Example:import aiofiles
import miniasync

async def get_file_content(filename):
    async with aiofiles.open(filename, mode='r') as f:
        return await f.read()

results = miniasync.run(
    get_file_content('file1.txt'),
    get_file_content('file2.txt'),
)

assert results == [
    '<the content of file1.txt>',
    '<the content of file2.txt>'
]See thedocumentation on readthedocsfor more examples and API.LicenseCopyright © 2018, Alice Heaton. Released under theLGPL 3 LicenseChangesV0.1.2Documentation fixesV0.1.1Documentation improvementsV0.1.0Initial implementation: miniasync.run and miniasync.loop
Package: miniav
MiniAV ProjectThe MiniAV project is meant to be a testbed for automated driving algorithm development and is to be used as a mechanism for validating the simulation platformChrono. The MiniAV platform is under activate development by theSimulation Based Engineering Laboratoryat theUniversity of Wisconsin-Madison.BackgroundThe MiniAV platform provides the following resources for expediting development of autonomous algorithms:A parts list and instructions on how to build the physical platformA high-fidelity simulation environment built usingChronoto test autonomous algorithmsA development workflow for writing ROS 2 code and various already implemented algorithmsA database system to expedite data recording and parsing and an accompaning command line interfaceFor more information about the design considerations and purpose for this project, see thebackgroundsection.SupportContact theSimulation Based Engineering Laboratoryfor any questions or concerns regarding the contents of this repository.See AlsoVisit our website atsbel.wisc.edu!
Package: miniball
miniballA Python module to efficiently compute the smallest bounding ball of a point
set, in arbitrary number of dimensions.The algorithm runs in approximatively linear time in respects to the number of
input points. This is NOT a derivative nor a port ofBernd Gaertner’s C++ library.This project is licensed under the MIT LicenseRequirementsminiball 1.2 requiresPython >= 3.5Numpy >= 1.17Installation$pipinstallminiballUsageHere is how you can get the smallest bounding ball of a set of pointsS>>>importnumpy>>>importminiball>>>S=numpy.random.randn(100,2)>>>C,r2=miniball.get_bounding_ball(S)The center of the bounding ball isC, its radius is the square root ofr2.
The input coordinatesScan be integer, they will automatically cast to floating
point internally.And that’s it ! miniball does only one thing with one function.Result accuracyAlthough the algorithm returns exact results in theory, in practice it returns
result only exact up to a given precision. Theepsilonkeyword argument allows
to control that precision, it is set to 1e-7 by default.>>>importnumpy>>>importminiball>>>S=numpy.random.randn(100,2)>>>C,r2=miniball.get_bounding_ball(S,epsilon=1e-7)RepeatabilityThe algorithm to compute bounding balls relies on a pseudo-random number generator.
Although the algorithms return an exact solution, it is only exact up to theepsilonparameter. As a consequence, running theget_bounding_ballfunction twice on
the same input might not return exactly the same output.By default, each call toget_bounding_ballpull out a new, freshly seeded
pseudo-random number generator. Therefore, if you wish to get repeatable results
fromget_bounding_ball, you have to (and only have to) pass the same pseudo-random
number generator, using with therngkeyword argument>>>importnumpy>>>importminiball>>>S=numpy.random.randn(100,2)>>>rng=numpy.random.RandomState(42)>>>C,r2=miniball.get_bounding_ball(S,rng=rng)Duplicated input pointsDuplicated input points might trigger failures. This implementation do not check
for duplicated input points, the guaranty of non-duplication is defered to you, the
programmer. This is by design, to avoid to pay the cost of de-duplication when we
are sure that the input has no duplicates.Implementation notesThe algorithm implemented is Welzl’s algorithm. It is a pure Python implementation,
it is not a binding of the popular C++ packageBernd Gaertner’s miniball.The algorithm, although often presented in its recursive form, is here implemented
in an iterative fashion. Python have an hard-coded recursion limit, therefore
a recursive implementation of Welzl’s algorithm would have an artificially limited
number of point it could process.AuthorsAlexandre Devert-Initial work-marmakoideLicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: minibar
A (WIP) python progress barInstallingpipinstallminibarUsageimportminibarimporttimeforiinminibar.bar(range(100)):time.sleep(0.05)Output:Minibar can be customizedtemplate="{i}/{total}{bar}{elapsed}s{eta}"foriinminibar(range(100),template=template):time.sleep(0.05)The following widgets are avaliable:{i}The numeric progress counter.{total}The total value.{bar}The progress bar.{elapsed}The time ellapsed in seconds.{eta}The estimated time to finish.
Package: minibench
MiniBench provides a simple framework for benchmarking following theunittestmodule pattern.Compatibilityminibench requires Python 2.7+.InstallationYou can install minibench with pip:$ pip install minibenchor with easy_install:$ easy_install minibenchQuick startWrite your benchmarks as you would write you unittests.
Just create a.bench.pyfile.# fake.bench.py
from minibench import Benchmark

class FakeBenchmark(Benchmark):
    '''Fake benchmark'''
    def bench_fake(self):
        '''Run my bench'''
        # Do somethingThen run it with thebenchcommand$ bench
>>> Fake benchmark (x5)
Run my bench ......................................... ✔ (0.1234s)DocumentationThe documentation is hostedon Read the DocsChangelog0.1.2 (2015-11-21)Improve diff from reference and added-u/--unitoptionProperly handle precision and added-p/--precisionoption0.1.1Fix Python 3 Wheel packaging0.1.0Initial release
Package: miniBenchmark
Minimalistic benchmarking of computers with general data/ modeling and simulation purposesThe two problems this package solve:What machine/ configuration should I buy to do mathematical modeling/ data analysis/ machine learning?I don't want to spend more money, how should I configurate parallelism/ backends to make the same code run faster?Both seem to have answers: Why not O complexities? Why not look for FLOPs? Why not just do divisions on frequencies?The answer is: time and memory consumptions, given a task, are metrics, they are not symbolic values, but distributions.Hence:We can run same tasks on different machines (or let others do) to compare configs.We can re-run same tasks on different configsBut it seems we can just time and verbose it, why bother?The thing is:You may need to test on some tasks that you don't have working code on--maybe I have that.Some benchmarking will take too long  and may fail, you need to handle that.You may want to compare your task to othersYou may be lazyKey functions:machine modeandtask modeInmachine modeyou expand the tasks and let it gradually reach the limit of the pc in a sequence, and get a dataframe of time, space etc. w.r.t tasksIntask modeyou tune the HPOs and compute compromise.But both returns dataframes, so it's easy to build and analyze the relations.Quick startBenchmarking:bench([matrices, DFTs, ls_pred,# matrix based predictor
	sgd_pred, gbdt_pred, symbolic_strings,
	iters,
	pdes, black_box_opts])Get machine and environment infos:detect_board()

detect_torch_availability()
detect_dask_availability()
detect_pycuda_availability()Search time/ memory checkpoints along with metrics w.r.t. HPOsearch_s(task = my_task,#an iterator, yielding one task at a time
	reset_func = my_task_reset, timeout = 1000, intra = 0, inter = 0)Fit relationships based on complexity curves.What if the program running is not in py?bench_kernel(task_command_dict, write_path)A benchmarking software to test computer performance.
2 modes:machine-centric mode: given one machine, enlist performace score for all tasks in a tasklisttask-centric mode: given one task, benchmark the machine on different configurations of the tasksInstallation:Any environment with tensorflow and torch. Although it is generally easier with Docker, considering the incompatibility of KVM on some older machines, and the different configuration of CUDA (some are within the containers, while others are not) we give this non-docker way of installationconda create --name mlgpu python==3.8
conda activate mlgpu
conda install tensorflow-gpu==2.7.1 -c conda-forge
conda install pytorch==1.10.1 torchvision==0.11.2 torchaudio==0.10.1 cudatoolkit=11.3 -c pytorch -c conda-forgeThis solves the problem onallmy machines and is able to run torch and tf in the same environment.
Package: minibert
MiniBertUn modèle dérivé de Bert, simplifié à l'extrême puisque le modèle n'est constitué que d'une couche d'attention.Dépendancespip install -r requirements.txt## Entrainementpython train_semevalLe script va entrainer un modèle sur le corpus SemEval et enregistrer ses performances dans le dossierruns.tensorboard --logdir=runs
Package: miniboa
Miniboa: a simple Telnet serverWhat?Miniboa is a bare-bones Telnet server to use as the base for a MUD or similar interactive server. Miniboa has several nice features for this type of application.FeaturesAsynchronous - no waiting on player input or state.Single threaded - light on resources with excellent performance.Runs under your game loop - you decide when to poll for data.Supports 1000 users under Linux and 512 under Windows (untested).Miniboa is compatible with both Python 2.7, and 3.xQuick StartFirst:pipinstallminiboaAnd then:fromminiboaimportTelnetServerserver=TelnetServer()whileTrue:server.poll()But you probably want to do something with the connecting/disconnecting clients:clients=[]defon_connect(client):client.send("Hello, my friend. Stay awhile and listen.")clients.append(client)defon_disconnect(client):clients.remove(client)server=TelnetServer(port=3333,address='',on_connect=on_connect,on_disconnect=on_disconnectencoding='utf-8')whileTrue:server.poll()To use Miniboa, you create a Telnet Server object listening at a specified port number. You have to provide two functions for the server; the first is a handler for new connections and the second is the handler for lost connections. These handler functions are passed Telnet Client objects – these are your communication paths to and from the individual player’s MUD client.For example, let’s say Mike and Joe connect to your MUD server. Telnet Server will call your on_connect() function with Mike’s Telnet Client object, and then again with Joe’s Telnet Client object. If Mike’s power goes out, Telnet Server will call your on_disconnect() function with Mike’s Telnet Client object (same exact one).This will launch a server listening on the default port, that accepts Telnet connections and sends a simple message.$telnetlocalhost7777Trying127.0.0.1...Connectedtolocalhost.Escapecharacteris'^]'.Hello,myfriend.Stayawhileandlisten.Further documentation can befound here.CopyrightCopyright2009JimStorchCopyright2015CareyMetcalfeCopyright2016JosephSchilzCopyright2018JaredMiller
Package: minibolt
A simple Neo4j database driver.RequirementCPython 3.5+https://www.python.orgor MicroPythonhttps://micropython.orgInstall# pip install miniboltSample Code>>> import minibolt
>>> conn = minibolt.connect('servername', 'username', 'password')
>>> rs = conn.run('MATCH (tom:Person {name: "Tom Hanks"})-[:ACTED_IN]->(movie) return movie.title')
>>> rs.fields
['movie.title']
>>> for r in rs:
...     print(r[0])
...
Charlie Wilson's War
The Polar Express
A League of Their Own
Cast Away
Apollo 13
The Green Mile
The Da Vinci Code
Cloud Atlas
That Thing You Do
Joe Versus the Volcano
Sleepless in Seattle
You've Got Mail
>>>NetworkX integrationSeehttps://gist.github.com/nakagami/a9c050ae76dc5a40eaeb67e6326b774e
Package: minibooks
minibooks is a simple CRM, bookkeeping and double entry accounting
package for the Django web framework.Example ProjectClone project and bootstrap virtual environment:~$ hg clone http://bitbucket.org/caktus/minibooks
~$ cd minibooks/example_project/portal
~/minibooks/example_project/portal$ mkvirtualenv --distribute portal
(portal)~/minibooks/example_project/portal$ ./bootstrap.pyCreate local_settings.py file, syncdb, and runserver:(portal)~/minibooks/example_project/portal$ cp local_settings.py.example local_settings.py
(portal)~/minibooks/example_project/portal$ ./manage.py syncdb
(portal)~/minibooks/example_project/portal$ ./manage.py runserverVisithttp://localhost:8000/in your browser.Development sponsored byCaktus Consulting Group, LLC..
Package: minibuild
======================Overview--------*MiniBuild* build system is a pure Python package aimed to buildexecutables, static and shared libraries from C, C++ and ASM sourcefiles. Build process can be launched from any directory containing a``minibuild.mk`` makefile. This file describes what type of binary isgoing to be built and its dependencies on other modules inside adirectory tree of your project.Supported toolchains and platforms:------------------------------------  Windows (i686, x86_64):-  Microsoft Visual Studio 2005, 2008, 2010, 2012, 2013, 2015, 2017-  MinGW-  Linux (i686, x86_64, arm-eabi, aarch64):-  GCC-  A range of gcc cross-toolchains generated by crosstool-ng:https://crosstool-ng.github.io-  MacOSX (x86_64):-  clangAssembly language support-------------------------By default ASM source files are supposed to be written in toolchaindefault assembly dialect (which is usually MASM or GAS depending ontoolchain being used for build). However threre is case, when your ASMsource files are written in NASM assembly language dialect. To prescribethis fact a corresponding option just has to be turned on in relatedmakefile.Documentation-------------Documentation is available at https://minibuild.github.io/minibuild/Keywords: buildsystem buildPlatform: LinuxPlatform: WindowsPlatform: MacOSXClassifier: Development Status :: 5 - Production/StableClassifier: Environment :: ConsoleClassifier: License :: OSI Approved :: MIT LicenseClassifier: Operating System :: POSIX :: LinuxClassifier: Operating System :: MacOS :: MacOS XClassifier: Operating System :: Microsoft :: WindowsClassifier: Programming Language :: PythonClassifier: Programming Language :: Python :: 2Classifier: Programming Language :: Python :: 2.7Classifier: Programming Language :: Python :: 3Classifier: Programming Language :: Python :: Implementation :: CPythonClassifier: Topic :: Software Development :: Build ToolsRequires-Python: >=2.7Description-Content-Type: text/x-rst
Package: minibump
MinibumpBump versions in changelogs and pyprojects and be minimalist about it:Only supportssemnatic versioning.Only supports standard tool-independent version fields inpyproject.toml.Only supports theKeep a changelogformat, in Markdown and withCHANGELOG.mdas a file name.Doesn't interact with git at all, either by inferring changelog entries from commits or making
commits or tags for you.Warns you if you try to set a version that is inconsistent with your changelog entries.InstallationInstallation withpipxis recommended. You might have toinstall
pipx itselffirst.pipx install minibumpUsageIncrement one of the semantic versioning segments usingbump:minibump bump [OPTIONS] SEGMENT [PROJECT DIR]WhereSEGMENTismajor,minor,patchorprereleasePROJECT DIRis an optional path to the root of the Python project to updateThis willChange the version inpyproject.tomlin the standardproject.versionfield, incrementing the
relevant part.Make a new release in your changelog (if present) from the content of the Unreleased section, with
the appropriate version number, link and date.If the segment you were asking to bump is inconsistent with the entries of your changelog, do
nothing and fail (see the--relax/--strictoption).Options:--dry-run: don't modify the files in place and prints the result in the console instead--relax/--strict: in strict mode (default), inconsistencies between changes and version make
minibump abort. in relax mode, this will simply result in a warning.Alternatively you can set a version yourself directly (in that case the default mode is relax) withset:minibump bump [OPTIONS] VERSION [PROJECT DIR]WhereVERSIONis the version to set, which still has to be semver-compatible.Inspirations and similar toolsMinibump is made to fit my own need as closely as possible. Although I would be glad to make evolve
to also suit other people's needs, you might also want to have a look atbump2versionandthe
alternativesthey suggest.As it is, Minibump is mostly a wrapper aroundsemverandkeep-a-changelog, withtomlkitas a backend for metadata parsing.LicenceThis software is released under the MIT Licence seeLICENCE.mdfor the details.
Package: minica-api-pihole-client
Minica API pihole clientA program for listening to domain discoveries published byminica-apiand injecting them into the custom DNS list used by pihole.Installation$ pip install minica-api-pihole-clientYou will probably want to install this package as root, as the DNS list at/etc/pihole/custom.listis owned
by root. Alternatively chown that file so this program is allowed to overwrite it as the running user.Usage$ minica-pihole-sync MQTT-HOST [-p mqttport] [-t domaintopic]
Package: minical
A simple calendar driven by text files, with an optional web UI.You can add/edit/remove events using the text tools of your choice, or use the scripts or web UI.Events look something like:$ cat events/medical_procedure

name: medical_procedure
date: 2020-10-09
start_time: 15:00
duration_minutes: 1
notes: address goes here
recurs: monthly
recurs_until: 2099-01-01
skip_dates: 2020-11-09,2021-03-09To remove an event, use "rm", or the web UI.Basic command examples# This uses Flask's built-in server. See further below on using gunicorn
# Use "src.minical" if running from project root and not an installed package
# Navigate to /cal/events after startup
MINICAL_PORT=5132 python -m minical.app

# List upcoming events
python -m minical.whats_next -s bday -a

# Point to events living somewhere else.
# This is one way to maintain separate calendars
MINICAL_EVENTS_DIR=/some/path/events python -m minical.whats_next

# There is an "entrypoint" if you install the package, just a CLI shorthand
# Equivalent to `python -m minical.app`
MINICAL_PORT=5132 minical-webThe "whats_next" CLI script shows something like:2021-05-29 (Sun), 01:01, friend_drinks (in 3 days)
2021-06-03 (Fri), 17:00, some_wedding (in 8 days)
2021-06-06 (Mon), 15:00, dr_foo_appt (in 11 days)
2022-05-17 (Wed), 01:01, some_birthday (in 356 days)
2022-08-01 (Tue), 01:01, award_ceremony (in 432 days)
2023-05-17 (Fri), 01:01, some_birthday (in 722 days)Building the packageWIP - haven't done this in a long time# Make an env wherever, outside of project dir,
# to make sure you're not importing files from same dir
python -m venv minical_build_test
source minical_build_test/bin/activate
# This is a tool from pypa
pip install build
# Go back into project dir with the setup.cfg. This command will make a 'dist' folder
python -m build
# Install the thing from the dist folder
pip install file:///home/.../dist/path/to/thing.tar.gzRunning with gunicorn# If installed
gunicorn -b 127.0.0.1:5132 minical.app:app
# If working with source
gunicorn -b 127.0.0.1:5132 src.minical.app:appOther featuresThere are none! No reminders or sharing. You shouldn't be so busy!
Package: minicapy
Minicapy, python bindings for minica, a mini CAA small python library for using minica to create ssl certificatesInstallationThis package is pip installable, simplypip install minicapyYou will need to have a fairly recent version ofgoandmakeinstalled
in order to build the library, because I can't figure out manylinux to provide
binary dist wheels.Usagefromminicapyimportminicasuccess=minica.create_domain_cert("somedomain.com")ifsuccess>0:print("Something went wrong")# Orsuccess=minica.create_ip_cert("10.0.0.25")ifsuccess>0:print("Something went wrong")Return codesThe functions return ints, which have the following meaningsReturn codeMeaning0Success1Couldn't create root cert files minica.pem/minica-key.pem2Couldn't create domain/ip cert, probably already exist
Package: minicloudstack
Makes it easy to connect to ApacheCloudStack.  Tested with version 4.2 and later.Includes helper scripts to work with zones and hosts and helps you get started with your own scripts.AlternativesThis library makes it easy to create quick utilities for Operational and Development purposes.
For an interactive shell you should trycloudmonkeyor shell scripting you can trycs.Installationpip install minicloudstackQuickstartExport the following environment variables (alternatively arguments can be used):exportCS_API_URL="http://mycloudstackapi.example.com/"exportCS_API_KEY="1235..."exportCS_SECRET_KEY="abcdef..."Start your python shell (python or ipython).importminicloudstackmcs=minicloudstack.MiniCloudStack()fortemplateinmcs.list("templates",templatefilter="featured"):printtemplate.id,template.nameHelper scriptsAlso provided are the following scripts that can be useful:mcs-createzonemcs-deletezonemcs-registertemplatemcs-addhostmcs-volumeminicloudstackStart them with –help for detailed instructions.BackgroundThese scripts were created byGreenqloudwhen developingQstack.We hope you find them useful!Greenqloud Dev Team.