Saravanan666/pypi-org huggingface dataset:
Package: minidynamicrender
DynamicRender用于将B站的动态渲染为图片（需要配合适配器将动态转化为特定格式）使用安装pipinstalldynamicrender1. 格式化动态# 如果数据是grpc返回的数据fromgoogle.protobuf.json_formatimportMessageToDictfromdynamicadaptor.DynamicConversionimportformate_messagefrombilirpc.apiimportget_dy_detailimportasynciofromdynamicrender.CoreimportDyRenderasyncdefsample1():dynamic_grpc=awaitget_dy_detail("746530608345251842")dynamic:dict=MessageToDict(dynamic_grpc[0])dynamic_formate=formate_message("grpc",dynamic)render=DyRender()# DyRender 实例化时可以传两个参数#1. data_path: {str} 为静态文件所在的位置，当data_path内不存在Static目录，则会自动解压自带的Static到data_path内# 2.font_path: {str/dic}当font_path为str类型的时候必须为字体的路径，路径不存在的话会使用默认的字体# 不建议使用传dict的方法修改字体# 当font_path为dict的时候必须为如以下所示的dict:"""{text: strextra_text: stremoji: str}三个都必须是字体的路径，text为文本主体的字体路径，extra_text为备选字体的路径，emoji为emoji字体的路径，注意！！！每款emoji字体的字体大小都有固定值，如果修改了emoji字体必须同时修改emoji字体的字体大小"""result=awaitrender.dyn_render(dynamic_formate)result.show()asyncio.run(sample1())# 如果是web返回的数据importasyncioimporthttpxfromdynamicrender.CoreimportDyRenderfromdynamicadaptor.DynamicConversionimportformate_messageasyncdefsample2():url="https://api.bilibili.com/x/polymer/web-dynamic/v1/detail?timezone_offset=-480&id=746530608345251842"headers={"Referer":"https://t.bilibili.com/746530608345251842"}result=httpx.get(url,headers=headers).json()dynamic_formate=formate_message("web",result["data"]["item"])render=DyRender()result=awaitrender.dyn_render(dynamic_formate)result.show()# asyncio.run(sample2())示例
Package: miniecs-test-package-Jeremias-V
Mini Elastic Container Service PackageThis isNOTintended for commercial use, neither for developing any application.This package is just for a project of the Operating Systems course at my university.The build is done with the following script.#!/bin/bashrmdist/*VERSION=$(grep"version"setup.cfg|awk-F.-vOFS=.'{print $3 + 1}')sed-i-e"/version =/ s/= .*/= 0.0.$VERSION/"setup.cfg

python3-mbuild

python3-mtwineuploaddist/*The default socket ip islocalhostand the port65535. To change either value you must use the class constructor, an example is presented below:fromminiecs_test_packageimportminiecsCONNECTION=miniecs.MiniECS(address='192.168.1.100',port=8080)CONNECTION.create_container(name='Test_Container')CONNECTION.stop()# To stop the socket connection.
Package: mini-fastapi-gateway
Mini FastApi GatewayFastAPI Gateway is a user-friendly microservices gateway built on the FastAPI framework, employing the same syntax for endpoint definitions. Its primary objective is to streamline the process of defining endpoints for microservices within a database and subsequently utilizing them within a gateway.At present, the gateway exclusively supports the definition of endpoints within a database and their utilization within the gateway. However, future enhancements are planned to enable the extraction of endpoints from files for use within the gateway.Installationpipinstallmini-fastapi-gatewayUsageSet environment variablesGATEWAY_DB_URL=postgresql://user:password@localhost:5432/db_nameUse GatewayRouter instead of FastApi in your main filefromgatewayimportGatewayRouter,gateway_crud_routerapp=GatewayRouter()app.include_router(gateway_crud_router)Make migrationsgateway-migrateNow you can use your dynamic gateway
Package: miniff
miniff: a minimal implementation of neural-network force fieldsCompute energies and forces of atomic systems with neural networks.AboutThis package implementsBehler and Parrinelloapproach to simulating
structures and dynamics of atomic systems. You may want to use it if:you are interested in structural properties of a system with many atoms such as a molecule or an amorphous material;your system is too large for electronic structure treatment (e.g. density functional theory molecular dynamics);no empiric potentials for your system exist ...... or the existing empiric potentials are not sufficient to reach the desired tolerances in energies and forces;you are interested in machine learning techniques for materials science problems and are looking for a good starting point for your research.The package is written in Python3.Built withpytorchis the machine learning and autodiff driver for this package;cythonis used for performance-critical tasks such as computing descriptors and their
gradients;numpyis the tensor and data engine in addition totorch;scipyis used for sparse data, neighbor search and optimization.In addition,matplotlibis used for plotting, andnumericalunitsis used for handling units.DocumentationHosted onRead the Docs.InstallPrerequisitesPython3C compiler: Required for compiling Cython extensionsExamplesDebian Linuxapt-getinstall-ybuild-essentialpython3-devpython3-pipFedoradnfgroupinstall"Development tools""Development libraries"MacOS:Installgccand make sure it is used by default.brewinstallgccAdd to.bash_profilepath and alias:exportCC=/usr/local/bin/gcc-10aliasgcc='gcc-10'Windows:On Windows, the support for installing a C compiler and compiling cython extensions is cumbersome and outdated
as can be inferred from theCython Wiki.
We suggest to use the Windows subsystem for Linux (WSL) in this case.
More information on WSL and its installation instructions arehere.Install from gitgitclonehttps://gitlab.kwant-project.org/qt/miniff.gitcdminiff
pythonsetup.pyinstallInstall from pippipinstallminiffUsefromminiff.ml_utilimportfitfit(prepare=dict(fn_cells="cells.json"),run=dict(n_epochs=1),)CLIminiffsupport basic command-line interface to most common workflows.python-mminiffjobs.ymljobs.yml:fit:prepare:fn_cells:cells.jsonrun:n_epochs:1ContributingSee CONTRIBUTING.md for contirbution guidelinesAuthorsSee AUTHORS.MD for the list of contributorsLicenseThis work is licensed under the BSD 2-Clause License
Package: mini_fiction
Library CMS on Python for fanfics. Currently in development.Short feature list: fanfics with genres, characters and events; comments
with trees; search (usingSphinx); user profiles
with contacts; premoderation of fanfics; favorites and bookmarks; notices
from administrator; PJAX-like loading of page content; customizable design;
primitive plugin system.CMS currently in Russian, and we would be grateful for the translation
of all phrases in English.Quick startInstall lxml. Then:pip install mini_fiction
mkdir media
mini_fiction seed
mini_fiction createsuperuser
mini_fiction runserverWebsite will be available athttp://localhost:5000/, administration page ishttp://localhost:5000/admin/.Configuration fileJust copylocal_settings.example.pytolocal_settings.pyand edit it.
Then runmini_fiction runserverin the same directory with this file.If mini_fiction can’t import modulelocal_settings, try to set environment
variablePYTHONPATH=.(don’t forgetexport PYTHONPATHfor unix
shells).If you want to change domain (e.g.127.0.0.1:5000orexample.cominstead of defaultlocalhost:5000), changeSERVER_NAMEoption.You can runmini_fiction statusto check some configuration variables.Search, avatars and captcha are disabled by default.For more information seeINSTALL.md(in Russian).
Package: minifit
MiniFitCopyright (C) 2023-- Michał KopczyńskiMiniFit is a Python package that usesscipy.optimize.curve_fit()to find optimal parameters of a chosen model function that best resembles the data.Poptfound will minimizemodel_function(xdata, *popt) - ydata.Documentation:https://minifit.readthedocs.io/en/latest/index.html
Package: miniflask
MiniFlaskMiniflask is asmallresearch-orientedplugin-engine forpython.A long time ago in a galaxy full of plugin-engines ...Quick StartFor a quick look into miniflask, just install it usingpipinstallminiflaskRead the DocumentationShort ExampleModule DefinitionLet's start a new project first by creating a new directory:>ls
main.py
modules/module1/__init__.pymodule2/__init__.pymodule1/__init__.pyLet's define a simple module,modules/module1/__init__.py:defmain(state,event):print("main event called by module1")defregister(mf):mf.register_event('main',main,unique=False)Let's define another module,modules/module2/__init__.py:defmain(state,event):print("main event called by module2")print("it uses a variable var:",state["var"])defregister(mf):mf.register_defaults({"var":42})mf.register_event('main',main,unique=False)Our main.py looks like this:importminiflask# initialize miniflaskmf=miniflask.init(".modules")mf.run()Usage:Now, we can use our program in the following ways:>pythonmain.py
Thereisnothingtodo.>pythonmain.pymodule1
maineventcalledbymodule1>pythonmain.pymodule2,module1
maineventcalledbymodule2
itusesavariablevar:42maineventcalledbymodule1>pythonmain.pymodule2,module1--module2.var9001maineventcalledbymodule2
itusesavariablevar:9001maineventcalledbymodule1ContributingFork it!Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull RequestLicense- SeeLICENSEfor details.
Package: miniflux
Python client library for Miniflux API.RequirementsMiniflux >= 2.0.49Python >= 3.7requestsInstallationpython3-mpipinstallminifluxRunning Testspython3-munittest-vUsage Exampleimportminiflux# Creating a client using username / password authenticationclient=miniflux.Client("https://miniflux.example.org",username="my_username",password="my_secret_password")# Use an API Key (preferred method)client=miniflux.Client("https://miniflux.example.org",api_key="My secret API token")# Get all feedsfeeds=client.get_feeds()# Refresh a feedclient.refresh_feed(123)# Discover subscriptions from a websitesubscriptions=client.discover("https://example.org")# Create a new feed, with a personalized user agent and with the crawler enabledfeed_id=client.create_feed("http://example.org/feed.xml",category_id=42,crawler=True,user_agent="GoogleBot")# Fetch 10 starred entriesentries=client.get_entries(starred=True,limit=10)# Fetch last 5 feed entriesfeed_entries=client.get_feed_entries(123,direction='desc',order='published_at',limit=5)# Fetch entries that belongs to a category with status unread and readentries=client.get_entries(category_id=456,status=['read','unread'])# Update entry title and contentclient.update_entry(entry_id=1234,title="New title",content="New content")# Update a feed categoryclient.update_feed(123,category_id=456)# OPML Exportopml=client.export_feeds()# OPML importclient.import_feeds(opml_data)# Get application versionclient.get_version()# Flush historyclient.flush_history()# Get current usermyself=client.me()Look atminiflux.pyto get the complete list of methods.AuthorFrédéric GuillotLicenseThis library is distributed under MIT License.
Package: minifold
MinifoldOverviewMinifoldis aPythonmodule able to interact with various data sources (e.g. CSV, LDAP, SQL, twitter, etc.) and to query/combine/aggregate them with database-like operators.Use casesThis framework has been in various Nokia projects. It also used in theLINCSwebsite to generate:trombinoscopehomepagesco-author graph, thanks topyBGLandGraphVizFor more information, feel free to visit thewiki:OverviewInstallationTutorialDesignConfigurationFrameworkTestsPackagingLicenseThis project is licensed under the BSD-3-Clause license - see theLICENSE.
Package: minifrpy
mypyPrésentationCet intepreteur est capablede traiter Des opérations arithmétiques, Des opérations de comparaisons, Des conditions, Des boucles for et whilede définir et d’appeler une fonction , une variablede reconnaitre trois types d’objets :float , int , str avec la commande type
dispose des commandes :ecris pour afficher une chaine, conca pour la concaténation de deux chaines  , double pour doubler une chaine ou un nombre, occur ,  pour chercher le nombre d’occurence d’un mot dans un url donné et quit pour quitter le programme .UtilisationPour l’utiliser simplement:$ mypyfrmypy>depuis l’intepreteur python:>>> from mypy import interpreter
>>> interpreter.main()mypy>Pour lancer les tests:>>> from mypy import testsles tests seront lancés automatiquement
Package: minifzf
Lightweight and efficient Python library inspired by the powerful features offzf, the popular command-line fuzzy finder.minifzfis designed to bring the essential functionalities offzfinto your Python CLI projects with ease and simplicity.Key Features:Basic FZF Functionalities: Incorporates the fundamental features offzf, offering efficient and fast fuzzy finding and selection capabilities right in your command line.Library Use: Can be easily imported and used as a module in other Python projects, enhancing the interactive command-line interface experience.Simplicity and Efficiency: Stripped down to core features, ensuring a lightweight and straightforward user experience without the overhead of complex functionalities.Ideal Use Cases:Interactive data selection and navigation in Python CLI applications.Quick searching and filtering in command-line based tools or scripts.Enhancing existing Python projects with simple, efficient selection capabilities.Developers seeking a minimalistic yet powerful alternative tofzffor Python.Installation:pipinstallminifzfCLI Usage:$ mfzf --help

Usage: minifzf COMMAND [OPTIONS]

╭─ Commands ────────────────────────────────────────────╮
│ --help,-h     Display this message and exit.          │
│ --version,-v  Display application version.            │
╰───────────────────────────────────────────────────────╯
╭─ Parameters ──────────────────────────────────────────╮
│ --query  -q  Start the selector with the given query. │
│ --first  -1  Automatically select the only match.     │
╰───────────────────────────────────────────────────────╯Startminifzfselection for current directory.mfzfWith initial query.minifzf-q"<Your Query>"Returned most relevant item.mfzf-q"<Your Query>"-1Select from Standard Input.No UNIX support for now (Throws[Errno 25] Inappropriate ioctl for devicebecause minifzf uses sshkeyboard which utilizes termios library.)catfilename|minifzfLibrary Usage:Initiating selector with headers and rows.fromminifzfimportSelectorfrompathlibimportPathselector=Selector(headers=['files'],rows=[[str(p)]forpinPath.cwd().glob('*')])selected=selector.select()Initating selector with mappings.fromminifzfimportSelectormappings=[{"id":"51009","name":"Jujutsu Kaisen 2nd Season"},{"id":"40748","name":"Jujutsu Kaisen"},{"id":"48561","name":"Jujutsu Kaisen 0 Movie"}]selector=Selector.from_mappings(mappings=mappings)selected=selector.select()Initiating a path selector.fromminifzfimportSelectorfrompathlibimportPathpath_selector=Selector.as_path_selector(directory=Path('path/to/directory'),recursive=False)selected=path_selector.select()Contribution and Feedback:We welcome contributions and feedback to improveminifzf. If you have ideas, issues, or want to contribute, please feel free to open an issue or a pull request.
Package: miniga4py
miniga4pyMinimal Python bindings for the Global Arrays Toolkit Library.
Implements asubsetof thega4pyPython library.Provides miniga4pythe Python package that allows the usage of the Global Arrays Toolkit
Library from Python3.It has been developed to be used inLARGEWARNING:Installnumpy,mpi4pyandglobalarraysbeforeinstalling miniga4py!Install the packagepip3 install miniga4pyOr download the whole repository:git clone https://bitbucket.org/bvidmar/miniga4pyand thencd miniga4pyand install as preferred:python3 setup.py installpip3 installCheck the installationmpiexec -n 4 testminiga4pyThe AuthorRoberto VidmarThe MantainersRoberto VidmarNicola Creati
Package: mini-groove
mini-grooveJust a little learning experiment with Rust. The goal was to make a simple geospatial Rust/Python library (installable fromPyPI). Thanks to the great utilities byGeoRustandPyO3/maturin, it was not hard at all (so far). To be continued (or not)...The library can be used for smoothing and simplifying polygon geometries (from GeoJSON or WKT). Benchmarking is yet to be done, but it seems to be reasonably fast already.
Package: mini_gui_games
Mini_GUI_Gamessmall funny gamesInstallationRun commandpip install mini_gui_gamesin terminal or command line to install package with games.UsageUse commandgamesorminiguigamesormini_gui_gamesto show list of avaialable games.Run commands:bandergoose
hanoitower
snake
tictactoeto launch the corresponding gameScreenshotsHannoiTowerTicTacToeSnakeBanderGoose
Package: minigun-soren-n
NoticeThis project is WIP, but almost done!ImplemtationDocumentationDependenciesMinigunA QuickCheck-like library for property-based unit-testing of Python programs.Minigun is inspired byQCheck, which in turn was inspired byQuickCheck. Both are libraries that provide implementations for performing property-based unit-testing; for OCaml and Haskell respectively.If you would like a bit of motivation as to why you should use a QuickCheck-like system for testing your project, then I would recommend that you watch:John Hughes - Testing the Hard Stuff and Staying SaneJohn Hughes - Certifying your car with ErlangIf you wish to learn more about the subject, I can recommend Jan Midtgaard'slecture materials; it is OCaml based but translates easily to other QuickCheck-like libraries for other languages.InstallMinigun is currently only supported for Python >=3.10, although it might work with older versions. It is distributed with pip and can be installed with the following example command:$ python3 -m pip install minigun-soren-nDocumentationA tutorial as well as reference documentation for the API can be found atRead The Docs.ExamplesThe following projects use Minigun for testing:MinigunTickleIf you have used Minigun for testing of a public project, and would like it added to the list, then please file an issue with a link to the project.
Package: minigym
minigymmore gym environmentsFrozenIslandenv=gym.make('minigym:FrozenIsland-v0')Under the hood theFrozenLake-v0is used.Platformerenv=gym.make('minigym:Platformer-v0')AcknowledgementThis project is usingBox2D.This projects is using assets fromwww.kenney.nl.
Package: minihex
MiniHexAnOpenAI gymenvironment that allows an
agent to play the game ofHex.
The aim for this environment is to be lean and have fast rollouts, as well as,
variable board size. With random actions it currently achieves~340 games per secondin a 11x11 grid (original size) on a single CPU
(Intel Xenon E3-1230 @3.3GHz).Hex is a two player game and needs to be converted into a "single agent
environment" to fit into the gym framework. We achieve this by requiring aopponent_policyat creation time. Each move of the agent will be immediately
followed by a move of the opponent. This is a function that takes as input a
board state and outputs an action.Installationpip install minihexEditable installation (if you wish to tweak the environment):git clone https://github.com/FirefoxMetzger/minihex.git
pip install -e minihex/Minimal Working Exampleimport gym
import minihex


env = gym.make("hex-v0",
               opponent_policy=minihex.random_policy,
               board_size=11)

state, info = env.reset()
done = False
while not done:
    board, player = state
    action = minihex.random_policy(board, player, info)
    state, reward, done, info = env.step(action)

env.render()

if reward == -1:
    print("Player (Black) Lost")
elif reward == 1:
    print("Player (Black) Won")
else:
    print("Draw")Debug ModeIf the environment is instantiated withdebug=Trueeach step will check if a
valid action is provided, and anIndexErrorwill be raised if an invalid one
is provided. This is very useful while writing agents, e.g., if the agent
maintains it's own belief over the environment and may request invalid actions.
When evaluating/running at scale, however, this check can cause significant
slowdown. Hence, it is only performed if explicitly requested.LimitationsCurrently the enviornment is missing the following features to go to version 1.0The swap action that is used to mitigate the disadvantage of playing second.RGB rendering modeadd environment to pypino surrender actionBugs and ContributingIf you encounter problems, check theGitHub issue pageor open a new issue there.
Package: minihtml
Simple HTML generationInstallationInstall theminihtmlpackage from PyPI:$ pip install minihtmlExamplesCreate aminihtml.Htmlinstance to produce tags. Tags stringify to HTML:>>>fromminihtmlimportHtml>>>h=Html()>>>html=h.html(h.head(h.title("Hello, World!")))>>>print(html)<html><head><title>Hello,World!</title></head></html>Tags are callables that accept positional arguments (children) and keyword
arguments (attributes). Calls can be chained to produce code that is structured
more like HTML (attributes before content):>>>print(h.a("link title",href="/url"))<ahref="/url">linktitle</a>>>>print(h.a(href="/url")("link title"))<ahref="/url">linktitle</a>There are shortcuts for setting theclassandidattributes using[]accessors:>>>print(h.div["#header bg-white"](h.span["text-xl font-medium"]("hello")))<divid="header"class="bg-white"><spanclass="text-xl font-medium">hello</span></div>Text content, attribute names and attribute values are escaped automatically.
To include unescaped content, use therawelement. Only use this withtrustedinput:>>>print(h.div(foo='"bar"')("2 > 1"))<divfoo="&quot;bar&quot;">2&gt;1</div>>>>print(h.script(h.raw('if (2 > 1) console.log("math still works");')))<script>if(2>1)console.log("math still works");</script>To use tag or attribute names that conflict with python keywords, append an
underscore. Underscores within attribute names are converted to hyphens ("-",
except for a single underscore, which is passed through unchanged).>>>print(h.del_("deleted text"))<del>deletedtext</del>>>>print(h.label(for_="fieldname")("text"))<labelfor="fieldname">text</label>>>>print(h.span(data_foo="bar"))<spandata-foo="bar"></span>>>>print(h.span(_="something"))<span_="something"></span>Attributes that have no value can be set by passing the valueTrue:>>>print(h.input(type="text",disabled=True))<inputtype="text"disabled/>Useminihtml.tostringto convert a tag to a string and add a doctype:>>>fromminihtmlimporttostring>>>html=h.html(h.body("my website"))>>>tostring(html)'<!doctype html>\n<html><body>my website</body></html>\n'Licenseminihtml is licensed under the MIT license. See the included fileLICENSEfor details.
Package: minihydra-leviathan
pip install minihydra-leviathanReading in args# run.pyfromminihydraimportjust_argsargs=just_args()print(args,'\n')print(args.hello)print(args.number)print(args.goodbye.cruel)> python run.py hello=world number=42 goodbye.cruel='[world]'

{'hello': 'world', 'number': 42, {'goodbye': {'cruel': ['world']}}}

world
42
[world]Via yaml# path/to/args.yamlhello:worldnumber:42goodbye:cruel:-world# run.pyfromminihydraimportjust_argsargs=just_args(source='path/to/args.yaml')print(args,'\n')print(args.hello)print(args.number)print(args.goodbye.cruel)> python run.py number=43

{'hello': 'world', 'number': 43, {'goodbye': {'cruel': ['world']}}}

world
43
[world]As a decorator# run.pyfromminihydraimportget_args@get_args(source='path/to/args.yaml')defmain(args):print(args)if__name__=='__main__':main()> python run.py

{'hello': 'world', 'number': 42, {'goodbye': {'cruel': ['world']}}}AdvancedFurther features include literals, function calls, instantiation, imports, interpolation, custom grammars, expanding module and yaml search paths, project directory inference, instantiation tinkering-syntax inference, portals, and pseudonyms.For deeper documentation, please considersponsoring.Licensed under the MIT license.
Package: mini-init
mini-init简单辅助工具集合: 日志, 配置文件, 环境变量等加载依赖pipinstallmini-init读取环境变量# .envPROJECT_NAME=mini-init...fromdataclassesimportdataclassfromminiinitimportenv@dataclassclassEnv:# 环境变量PROJECT_NAME:str=''...env_data=env.get_env(Env)# 更换路径# env_data = env.get_env(Env, '**/.env')print(env_data.PROJECT_NAME)# mini-init读取项目配置# 默认, 不可修改# config/application.yamlapp:name:mini-initversion:0.0.1log:is_use:trueyaml_path:config/log.yamlbanner:is_show:truefile_path:banner.txtwelcome:welcome use mini-init (v0.0.1)# 其他参数自行扩展...fromdataclassesimportdataclassfromminiinitimportconfig@dataclassclassConfig(config.Config):# 自定参数, 也可覆盖...config_data=config.get_config(Config)print(config_data.app.name)# mini-init