Saravanan666/pypi-org huggingface dataset:
Package: minetext
minetextMINEis a collaboration project between theNiedersächsische Staats- und Universitätsbibliothek Göttingen (SUB)and theGesellschaft für wissenschaftliche Datenverarbeitung Göttingen (GWDG)with the goal to offer a convenient platform
for text analysis.minetextis a Python package, which facilitates the interaction between Python clients and the MINE system. For other
clients,REST APIof MINE is the way to go.Note:minetextonly works on Python version>=3.7.To install it, simply run$pipinstallminetextExamplesSimple searchfromminetextimportEsRequest,Minees_request=EsRequest(search_term='biology')mine=Mine(es_request)response=mine.search()forhitinresponse:print(hit.meta.score,hit.mine.dc_title)The example above shows us how to search in MINE. It is done in 3 steps:Line 3: create an instance of theEsRequestclass with
the query set tobiology.Line 4: create an instance of theMineclass. Since all
operations are done via this instance,
creating this instance is the first required step to interact with the MINE system.Line 6: search for the wordbiologyin MINE. To access the result, simply loop through theresponse, as shown
in line 8.Get full-textfromminetextimportEsRequest,Mine# Search for all documents which have full-textes_request=EsRequest(search_term='_exists_:content')mine=Mine(es_request)mine.login()response=mine.search()forhitinresponse:print(hit.content)To access the full-text, authentication is required. It is done by calling theloginmethod of theMineclass,
as shown in the example above on line 7. The full-text, if existed, will be accessible viahit.content. The syntax of
thesearch_termis thequery string syntax.For consecutive runs, the credentials is re-used so that users do not have to log in for every run. For more details,
please check theAuthenticationsection.Note: theresponseobject is an instance of theResponseclass from theelasticsearch-dslpackageFor more information, please refer to thefull documentation.
Package: minetime
Minetime is a command line application to help you collect timelogs and post them to a configuredRedmineproject management application via itsREST API, using thepython-redminelibrary.FeaturesInteractive wizard. In wizard mode, user gets to select issues from assigned issues and tracked queries, add, delete, edit, merge or round timelogs.GTimelogintegration.Universal Time Trackerintegration.Project Report created to expose minetime project time entries per version. Optimized for redmine with Backlog Plugin.Basics:minetime Homepage,minetime DocumentationPackage & Build Status:License:GPL LicenseIssue tracker:Gitlab IssuesInstallation# install minetime
pip install minetime

# upgrade minetime
pip install --upgrade minetimeor, without pip, from source:python setup.py installMain Configuration FileDefault location:$HOME/.config/minetime/config.yml. Format: YAMLThe default location may be overwritten by the MINETIME_CONF environment variable.Here’s an example of the main configuration file:general:uri:https://redmine.mydomain.com/user:api_key:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXactivity_id:9tracked_queries:-10001-10002-10003tracked_reports:-my_report_string_idactivities:9:DeveloppementConfiguration directory and file are not created upon installation. You may create them manually or launch minetime for the first time and the configuration wizard will kick in.You can find your API key on your redmine account page ( /my/account ) when logged in, on the right-hand pane of the default layout. Rest API has to be activated on the redmine instance. SeeRedmine Rest API Documentationfor more in depth details.Using minetimeminetime --help

Usage: minetime [OPTIONS] [INPUT]

Options:
  -a, --all                       Import all timelogs in --batch, regardless
                                  of --date.
  -d, --date TEXT                 YYYY-MM-DD date of timelogs, default: today.
  -b, --batch [gtl|utt]           Read GTimelog|utt from input. See GTimelog
                                  integration documentation.
  -t, --timelog <INTEGER FLOAT TEXT INTEGER>...
                                  ISSUEID, HOURS, COMMENTS, ACTIVITYID
                                  HOURS: decimal float (0.25 : 15 minutes).
  -i, --issues                    Show issues and exit. See GTimelog
                                  integration documentation.
  -r, --report                    Project Time Report for any tracked projects
                                  or manually-fed project-string.
  --debug                         Enable debug logging.
  --version                       Show the version and exit.
  --help                          Show this message and exit.Interactive CLI Wizard:minetimeExample feeding 2 timelogs from command line:minetime -t 123 0.75 "first time log", 9 -t 321 1.5 "second time log", 9Example importing gtimelog flat file:minetime -b gtl $HOME/.local/share/gtimelog/timelog.txtNote that this will importtoday’stimelogs. Use--dateto specify another day to import or--allto import everything found in input file.Project Report:minetime -r git-helloworld
Package: minevent
mineventOverviewmineventis a Python library that provides a minimal event system for Machine Learning.
It allows to customize a code by adding some piece of code that are executed when an event is
fired.mineventis organized around three main concepts:eventwhich defines the thing that should happen.event handlerwhich is the piece of code to execute when the event happensevent managerwhich is responsible to manage the events and event handlers.The library provides some implemented modules, but it is possible to extend it.
It is possible to use all the components or just a subset based on the need.
For example, an event handler can be used without the event manager.MotivationDocumentationInstallationContributingAPI stabilityLicenseMotivationmineventprovides a minimal event system to customize a piece of code without changing its
implementation.
Below is an example on how to usemineventlibrary.>>>frommineventimportEventHandler,EventManager>>>defsay_something(manager:EventManager)->None:...print("Hello, I am Bob!")...manager.trigger_event("after")...>>>manager=EventManager()>>>say_something(manager)Hello, I am Bob!>>>defhello_handler()->None:...print("Hello!")...>>>manager.add_event_handler("after",EventHandler(hello_handler))>>>say_something(manager)Hello, I am Bob!Hello!It allows to customize the functionsay_somethingwithout changing its implementation.
Please read thequickstart pageto learn more
about the library.InstallationWe highly recommend installing
avirtual environment.mineventcan be installed from pip using the following command:pipinstallmineventTo make the package as slim as possible, only the minimal packages required to usemineventare
installed.
To include all the dependencies, you can use the following command:pipinstallminevent[all]Please check theget started pageto see how to
install only some specific dependencies or other alternatives to install the library.
The following is the correspondingmineventversions and supported dependencies.mineventcoolapythonmain>=0.1,<0.3>=3.9,<3.130.2.1>=0.1,<0.3>=3.9,<3.130.2.0>=0.1,<0.3>=3.9,<3.130.1.0>=0.0.20,<0.2>=3.9,<3.130.0.5>=0.0.20,<0.0.24>=3.9,<3.120.0.4>=0.0.20,<0.0.24>=3.9,<3.12older versionsmineventcoolapython0.0.3>=0.0.20,<0.0.24>=3.9,<3.120.0.2>=0.0.20,<0.0.23>=3.9,<3.120.0.1>=0.0.20,<0.0.23>=3.9,<3.12ContributingPlease check the instructions inCONTRIBUTING.md.API stability:warning: Whilemineventis in development stage, no API is guaranteed to be stable from one
release to the next.
In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
In practice, this means that upgradingmineventto a new version will possibly break any code that
was using the old version ofminevent.Licensemineventis licensed under BSD 3-Clause "New" or "Revised" license available inLICENSEfile.
Package: minexr
minexrminexris a standalone, fast PythonOpenEXRreader for single-part, uncompressed scan-line files. It is compatible with.exrfiles produced byBlender.Assumptionsminexrmakes a couple of assumptions about the.exrfile to be read:single-part files with arbitrary number of channels,no pixel data compression, andequal channel types (HALF, FLOAT, UINT).These assumptions allow us to efficiently parse and read the.exrfile. In particular we gain constant offsets between scan lines which allows us to read the entire image in (H,C,W) format without copying.UsageThe following is taken fromexample.pyimportminexrwithopen('file.exr','rb')asfp:reader=minexr.load(fp)rgba=reader.select(['Color.R','Color.G','Color.B','Color.A'])# a HxWx4 np.array with dtype based on exr type....Fullexample.pyloads the following imageswhich were previously rendered using Blender/EEVEEcube.blend.RuntimeThe following timings are produced bybench.pyby repeatable reading an RGBA image from an.exrfile. Timings include file and numpy operations.Module[sec/image]NoteOpenEXR 1.3.20.020with channel concatenateOpenEXR 1.3.20.015without channel concatenateminexr0.004with channel concatenateInstallEither via pippip install minexrOr clone this repository and invokepip install -e .TestsTo run the testspytestBlender supportUse aFileOutputnode in Blender's compositor to export.exrfiles. Make sure to selectOpenEXR MultiLayerformat and setCODECto None as shown in the following image.Color Depthcan be chosen as required.When unsure about which channels are being written, you can inspect the file content as followsimportminexrwithopen('file.exr','rb')asfp:reader=minexr.load(fp)print(reader.channel_names)# ['Color.R','Color.G','Color.B', ...]print(reader.attrs)# Dictionary of all OpenEXR header attributes.
Package: miney
Miney - The python interface to minetestMiney is an Python API to Minetest.Miney connects locally, over network or internet to themineysocketmod of minetest.Documentationhttps://miney.readthedocs.io/en/latest/StatusBeta, the current todo list is in thewiki.RequirementPython 3.6+ (tested on 3.8)A minetest-server withmineysocketmod
Package: minfo
Mutual Information EstimatorPython-based mutual information estimator, designed for multiple data types.PrerequisiteNumpyCythonNumba# Make sure install numpy using conda.# Installation with pip may lead to unexpected errors.condainstallnumpycythonnumbaInstall OpenMP LibraryInstall OpenMP Library to enable CPU parallel acceleration for Time-delayed Mutual Information calculation.Linux:sudo apt-get install libomp-devMacOS:brew install libompInstallationTo install via pip:pipinstallminfoTo install via repository:gitclonehttps://github.com/NeoNeuron/minfocdminfo
pipinstall-e.Get StartedMI with uniform binsfromminfo.mi_floatimportmutual_info,TDMI# mutual_info : mutual information estimator#        tdmi : time-delayed mutual information estimatorn=100x=np.random.rand(n)y=np.random.rand(n)# compute mutual informationmutual_info(x,y,bins=50)# default algorithm: 'uniform'# compute time-delayed mutual information (Parallel accelerated)n_delay=10TDMI(x,y,n_delay,bins=50)# default algorithm: 'uniform'MI with adaptive binsATTENTION:This algorithm is designed for mutual information estimation between continuous variables. Applying it to discrete variables with few number of values might lead to large deviations. Modules for finite discrete cases are to be developed.ReferenceDarbellay, G. A., & Vajda, I. (1999).Estimation of the information by an adaptive partitioning of the observation space. IEEE Transactions on Information Theory, 45(4), 1315-1321.fromminfo.mi_floatimportmutual_info,TDMI# mutual_info : mutual information estimator#        tdmi : time-delayed mutual information estimatorn=100x=np.random.rand(n)y=np.random.rand(n)# compute mutual informationmutual_info(x,y,algorithm='adaptive')# compute time-delayed mutual information (Parallel accelerated)n_delay=10TDMI(x,y,n_delay,algorithm='adaptive')Compare performance with pure Python versionTest OS info:Laptop:MacBook Pro (15-inch, 2018)Systemversion: macOS Big Sur 12.4 (21F79)CPU:2.6 GHz 6-Core Intel Core i7RAM:32 GB 2400 MHz DDR4$cdexample
$pythonexample.py[INFO]:mi_adaptive(python)takes0.025s[INFO]:mi_uniform(numba)takes0.000s[INFO]:mi_adaptive(cython)takes0.009s[INFO]:tdmi_adaptive(python)takes0.560s[INFO]:tdmi_uniform(numba)takes0.005s[INFO]:tdmi_adaptive(cython)takes0.076s
Package: minFQ
A command line client for uploading sequencing metrics from Oxford Nanopore Technologies MinKNOW to a LooseLab minoTour
server instance.MinFQ only supports minknow core 4.X.X as it uses ONT’s minknow-api, which is only compatible with said version of MinKNOW.However, base called data can be uploaded from any version of MinKNOW/Guppy.To install -pipinstallminFQExample CommandsIn the example commands below example parameters are:your_user_key: is the long string found in the profile section of your minoTour account.url_to_your_minotour_server: Probably 127.0.0.1, could be a remote address like minotour.nottingham.ac.ukport_for_your_server: Probably 8000To monitor both live and fastq data.minFQ-k[your_user_key]-w/path/to/your/fastq/files-ip127.0.0.1-hn[url_to_your_minotour_server]-p[port_for_your_server]To monitor just live data from minKNOW.minFQ-k[your_user_key]-ip127.0.0.1-hn[url_to_your_minotour_server]-p[port_for_your_server]-nfTo monitor live data and enable limited remote control of minKNOW.minFQ-k[your_user_key]-ip127.0.0.1-hn[url_to_your_minotour_server]-p[port_for_your_server]-nf-rcTo monitor just fastq data.minFQ-k[your_user_key]-w/path/to/your/fastq/files-hn[url_to_your_minotour_server]-p[port_for_your_server]-nmTo monitor fastq statistics only. (Note you will not be able to run subsequent analysis on the server which requires sequence data).minFQ-k[your_user_key]-w/path/to/your/fastq/files-hn[url_to_your_minotour_server]-p[port_for_your_server]-nm-sTo start an analysis remotely whilst uploading data. Note reference Id may not be required.minFQ-k[your_user_key]-w/path/to/your/fastq/files-hn[url_to_your_minotour_server]-p[port_for_your_server]-nm-j[job_id]-r[reference_id]minFQ GuiWe are in the process of rebuilding a minFQ gui. Watch this space.
Package: mingdao
api_python==========For PythonInstall:========可以通过 pip 安装：pip install mingdao或下载后执行python setup.py install进行安装依赖 requests 库, 如果需要直接运行 demo, 还需要 bottle 库, 可通过下面的命令安装依赖pip install requestspip install bottleDemo:=====安装完成后可以通过python -m mingdao运行 demo，访问地址为 http://localhost:8000Usage:======请先在 http://open.mingdao.com 注册一个应用，并获取 app_key 和 app_secret## Configimport mingdaoapi = mingdao.API({'app_key': 你的 app_key(必填),'app_secret': 你的 app_secret(必填),'redirect_uri': 你设置的应用回调地址(必填),'throw_api_error': 在 API 返回错误码时是否抛出异常(可选),})## Authorize多数 API 需首先进行授权，获得 access_token详情请参阅[明道开发指南](http://open.mingdao.com/Home_document_intro.html)：用户登录后会回调应用的回调地址，并传递一个 code 参数，可用 api.authorize 方法进行授权：api.authorize(code)查看授权过期时间：api.expires_in # 授权有效期api.expires_at # 过期时间刷新授权：api.refresh()## Call API可通过 `api.分类名.接口名(参数)` 方式调用 API，access_token, app_key, app_secret 以及 format 参数无需指定。以动态更新接口 `/post/followed` 为例：result = api.post.followed({'keywords': '关键字','post_type': 1,'pagesize': 50,})result 为反序列化 API 接口返回的 JSON 字符串后生成的字典对象。API 接口详情请参阅[明道开发文档](http://open.mingdao.com/Home_document_intro.htm)
Package: mingdaoyun-sdk
mingdaoyun-Python-SDK针对mingdaoyun的API封装的Python-SDK包如果你在寻找PHP版本的,请点击(https://github.com/Lany-w/mingdaoyun-php-sdk)Installing$pipinstallmingdaoyun-sdkUsage```python
from mingdaoyun_sdk import Mingdaoyun
mingdaoyun = Mingdaoyun('your app id', 'your app sign','host')

mingdaoyun.table("table_alias").set_view("view_id").where("state", "=", "生效中").sort("autoid", True).find(all=True)

```APItable("table_alias/worksheetId")  设置表名set_view("view_id") 设置视图where("field", "operator", "value") 设置查询条件operator:contains=startWithendWithnotContain!=None 或者 "is null"not null>>=<<=RCEqRCNebetweennBetweenDateEnumNDateEnumDateBetweenDateNBetweenvalue:  如果是 DateBetween ， DateNBetween 要传 maxValue 和 minValuefind(rowid=None, pageSize=1000, pageIndex=1, all=False) 查询数据rowid 查询单条数据pageSize 每页条数pageIndex 页码all 是否查询所有add 添加数据batch_add 批量添加数据delete (rowid) 删除数据 rowid 为逗号拼接的字符串edit (rowid, controls) 编辑数据batch_edit (rowids, control) 批量编辑数据count() 统计数据LicenseMIT
Package: mingle
Mingle is a library and command line tool to allow you to read from many log files, line by line in chronological order.IntroductionMingle uses the python-dateutil module to flexibly attempt to parse the first part of each line as a datetime, and
provides a generator to access the lines in total chronological order, across the input files.It also offers a function to conveniently print the lines out in chronological order, optionally marking which files
the lines come from.A command line utility ‘mingle’ is also provided, to print the log file lines in chronological order from the shell.Usage:To access a generator that will return lines from multiple log files in chronological order:>>> from mingle import mingled
>>> files = ['webserver-log', 'db-log', 'firewall-log']
>>> for line, filename in mingled(files):
>>>     print("The line: " + line)
>>>     print("From file:" + filename)To conveniently print the lines to stdout:>>> import mingle
>>> files = ['webserver-log', 'db-log', 'firewall-log']
>>> mingle.cat(files)To print the usage of the command line interface:user@localhost:~$ mingle -h
usage: mingle [-h] [-q] files [files ...]

Inter-mingle the contents of several log files by date stamp.

positional arguments:
  files        the files to intermingle

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  strip the filename annotations from the output
Package: mingshe
MíngShéA betterPythonsuperset language. UsePegento compile the code.“鲜山多金玉，无草木，鲜水出焉，而北流注于伊水。其中多鸣蛇，其状如蛇而四翼，其音如磬，见则其邑大旱”——《山海经》DocumentationEnglishInstallpip install mingsheUsageAs a scriptWrite the following code tohello.she, and then runmingshe ./hello.she."hello world" |> printAs a moduleJust like use a python module, you can use a mingshe module.# lib.shedefdigit_sum(s:str)->int:returns|>map(int,?)|>sum# main.pyfromlibimportdigit_sumprint(digit_sum('123456'))Compile to pythonUsemingshe --compile ...to compile to Python code, and it can be compiled to the specified Python version:mingshe --compile --python 2.7 ....Change logReadreleasesto see the change log.
Package: mingus
mingus is a package for Python used by programmers, musicians, composers and researchers to make and investigate music. At the core of mingus is music theory, which includes topics like intervals, chords, scales and progressions. These components are
rigurously tested and can be used to generate and recognize musical elements using convenient
shorthand where possible (for example some acceptable chords are: CM7, Am6, Ab7, G7).On top of that are several packages that deal  with classical notation, MIDI (sequencing, loading and saving), MusicXML, ASCII tablature, and many other useful and plain cool things like LilyPond and FluidSynth support. Everything is fully documentated, put into simple APIs and has a tutorial making it easy to jump straight in.
Package: mingwtomsys
Installingpython -m pip install mingwtomsysUsage by exampleCommandResultmingw-to-msys clone -o D:\w\tmpclones MINGW-packages.git toD:\w\tmp\MINGW-packagesand MSYS2-packages.git toD:\w\tmp\MSYS2-packagesand stores paths in%APPDATA%\mingw-to-msys\config.jsonmingw-to-msys deps -p python-setuptoolsprints dependencies of packagepython-setuptoolsparsed fromMINGW-packages\mingw-w64-python-setuptools\PKGBUILDmingw-to-msys graph -p python-cryptographyprints dependency graph in dot language (for graphviz)mingw-to-msys convert -p python-idna -o D:\w\tmpconvertsMINGW-packages\mingw-w64-python-idnatoD:\w\tmp\python-idna,
replacing mingw-specific variables inPKGBUILD
Package: minha-aposta
package_nameDescrição.
O pacote minha_aposta é usado para:
- disponibilizar módulos com as modalidades dos seguintes jogos:
-quina
-megasena
-duplasena
-lotofacil
- gerar apostas com numeros aleatórios, dentro dos possíveis para cada modalidadeInstallationpipinstallminha_apostaUsefromminha_apostaimportquinaminha_aposta.quina.aposta()## Authornetotricca## License[MIT](https://choosealicense.com/licenses/mit/)
Package: miniabm
miniabmminiabm is a minimalist tool for agent-based modeling in python. This package allows the user to easily create objects with prespecified attributes, group the objects according the their attributes and change them dynamically in a batch.Get the packageTo download miniabm, either fork this github repo or use Pypi via pip:pip install miniabmUsageRead thedocsand seeexamples hereto quickly get started.
Package: miniadt
how to use## create Type

>>> from miniadt import ADTTypeProvider
>>> TreeType = ADTTypeProvider("Tree")

>>> Node = TreeType("Node", "e children")
>>> Leaf = TreeType("Leaf", "e")


## printing value

>>> Leaf(e=10)
Leaf(e=10)
>>> Node(e=10, children=[Leaf(e=20)])
Node(e=10, children=[Leaf(e=20)])


## use pattern match

>>> @TreeType.match
... class depth(object):
...     def Node(e, children):
...         return max(depth(e)for e in children) + 1
...
...     def Leaf(e):
...         return 1

>>> depth(Leaf(e=10))
1

>>> depth(Node(e=10, children=[Leaf(e=20), Node(e=30, children=[Leaf(e=40)])]))
3miniadt has comprehensive check function.## not comprehensive definition on pattern matching function error is occur

### 1. lack of dispatch andidates
>>> class invalid_dispatch(object):
...     def Node(e, children):
...         return "foo"

>>> TreeType.match(invalid_dispatch)
Traceback (most recent call last):
 ...
miniadt.NotComprehensive: Leaf is not found. expected=['Node', 'Leaf']


### 2. dispatch function's arguments are invalid.
>>> class invalid_dispatch2(object):
...     def Node(e):  ## correct argsspec is "e, children"
...         return "foo"
...     def Leaf(e):
...         return "foo"

>>> TreeType.match(invalid_dispatch2)
Traceback (most recent call last):
 ...
miniadt.NotComprehensive: on Tree.Node:  expected=['e', 'children'] != actual=['e']similar functionsmatchmatch_instanceclassifyfromminiadtimportADTTypeProviderTree=ADTTypeProvider("Tree")Node=Tree("Node","e children")Leaf=Tree("Leaf","e")print(Leaf(e=10))# => Leaf(e=10)print(Node(e=10,children=[Leaf(e=20)]))# => Node(e=10, children=[Leaf(e=20)])@Tree.matchclassdepth(object):defLeaf(e):return1defNode(e,children):returnmax(depth(e)foreinchildren)+1print(depth(Leaf(e=10)))# => 10print(depth(Node(e=10,children=[Leaf(e=20)])))# 2@Tree.match_instanceclassApplicator(object):def__init__(self,name):self.name=namedefLeaf(self,e):returnself.namedefNode(self,e,children):return[self.name,[self(x)forxinchildren]]print(Applicator("foo")(Leaf(e=10)))# => fooprint(Applicator("foo")(Node(e=10,children=[Leaf(e=20)])))# => ['foo', ['foo']]@Tree.classifyclassToDict(object):defLeaf(self,leaf):returnleaf.edefNode(self,node):return{"e":node.e,"children":[self(e)foreinnode.children]}todict=ToDict()print(todict(Leaf(e=10)))# => 10print(todict(Node(e=10,children=[Leaf(e=20)])))# => {'e': 10, 'children': [20]}
Package: minian-docker
MiniAn-dockerMiniAn-docker is docker builder forMinian. This package provides two type containers. (bashandnotebook).How to installinstall and run DocekrMiniAn-docker run on a Docker. Please install docker for your OS.install MiniAn-docker:pip install minian-dockerbuild and start docker container:
bash:minian-docker bashnotebook:minian-docker notebookContribution to MiniAn-dockerWe would love feedback and contribution from the community!LicenseThis project is licensed under GNU GPLv3.Acknowledgements____()()
         /      @@
   `~~~~~\_;m__m._>o
 _____  _____  _____  _____  _____  _____       ____   _____  _____  _____  _____  _____
|     ||     ||   | ||     ||  _  ||   | | ___ |    \ |     ||     ||  |  ||   __|| __  |
| | | ||-   -|| | | ||-   -||     || | | ||___||  |  ||  |  ||   --||    -||   __||    -|
|_|_|_||_____||_|___||_____||__|__||_|___|     |____/ |_____||_____||__|__||_____||__|__|Ascii art in the MOTD is adapted fromhttps://ascii.co.uk/art/miceandhttps://patorjk.com/software/taag/#p=display&h=1&f=Rectangles&t=MINIAN-DOCKER.