Saravanan666/pypi-org huggingface dataset:
Package: mansnip-kristopolous
"As seen on YouTube!" (click image, it's only 1min 45sec)Don't you hatewasting time navigating through manpages with the leading pager's clunky search tools?Ever try to find things like the "declare" built-in inbash(1)only to slodge through the results using the 'n' key going 'nope, nope, nope'?Stop wasting time with the old way of manually stumbling through manuals. Say goodbye to these problems once and for all!Finally there's a better way!Introducting Mansnip!Mansnip is a revolutionary way to navigate through manpages, a tool that no terminal should be without!It intelligently searches through manpages and outputs the snippets relevant to your query as self-contained browsable sections.
Simply use it the way you use man, at the command line, followed by your search term(s).Watch how mansnip can immediately findbash(1)'sdeclare without any extra effort:Mansnip works on any manpage.With mansnipyou'll just zip through documentation, saving precious time so you can write GitHub readmes like you're trying to sell Ginsu steak knives.See how mansnip obediently shows everything with a "-z" option in the 25,888 lines of thezshall manpageon a single screen, all at once, in an easy-to-read manner.But wait, there's more! You'll also get the line number and hierarchical context totally free!We're still not finished yet!You'll also get to install it easilythrough pypi.Here's how do it$ pip3 install mansnip-kristopolousAct now, servers are standing by.ＦＡＤＥ ＴＯ  ＢＬＡＣＫＥＮＤ ＳＣＥＮＥWant more? Here's somebackground
Package: mans-to-es
mans_to_esParses the FireEye HX .mans triage collections and send them to ElasticSearchTable of ContentsAboutGetting startedContributingDisclaimerAboutmans_to_es is an open source tool for parsing FireEye HX .mans triage collections and send them to ElasticSearch.Mans file is a zipped collection of xml that we parse usingxmltodict.
It uses pandas and multiprocessing to speed up the parsing with xml files.Getting startedInstallationpip install mans-to-esDevelopingIf you want to develop with the script you can download and place it under /usr/local/bin and make it executable.Usage as script$ mans_to_es.py --help
usage: MANS to ES [-h] [--filename FILENAME] [--name NAME] [--index INDEX]
                  [--es_host ES_HOST] [--es_port ES_PORT]
                  [--cpu_count CPU_COUNT] [--bulk_size BULK_SIZE] [--version]

Push .mans information in Elasticsearch index

optional arguments:
  -h, --help            show this help message and exit
  --filename FILENAME   Path of the .mans file
  --name NAME           Timeline name
  --index INDEX         ES index name
  --es_host ES_HOST     ES host
  --es_port ES_PORT     ES port
  --cpu_count CPU_COUNT
                        cpu count
  --bulk_size BULK_SIZE
                        Bulk size for multiprocessing parsing and upload
  --version             show program's version number and exitUsage as lib>>> from mans_to_es import MansToEs
>>> a = MansToEs()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() missing 5 required positional arguments: 'filename', 'index', 'name', 'es_host', and 'es_port'
>>> a = MansToEs(filename = '<file.mans>', index="<index>", name="<name>", es_host="localhost", es_port=9200)
>>> a.run()ContributingIf you want to contribute to mans_to_es, be sure to review thecontributing guidelines. This project adheres to mans_to_escode of conduct. By participating, you are expected to
uphold this code.**We useGitHub issuesfor
tracking requests and bugs.DisclaimerThis is not an official FireEye product. Bugs are expected.
Package: mantic
ManticCommand-line tools to facilitate se-mantic versioning!DemoInstallationpip install manticUsagemantic --help
mantic --help check-version
mantic check-versionLicenseCopyleft (ɔ) 2021 Mauko Quirogamauko@pm.meLicensed under the EUPL-1.2-or-later
For details:https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
Package: manticoresearch
Manticore Python clientСlient for Manticore Search.Requirements.Minimum Manticore Search version is >= 2.5.1 with HTTP protocol enabled.Manticore Searchmanticoresearch-pythonPython>= 6.2.04.0.0>= 3.4>= 6.2.03.3.1>= 3.4>= 4.2.12.0.x>= 3.4>= 4.0.2  < 4.2.11.0.6>= 3.4>= 2.5.1  < 4.0.21.0.5>= 2.7Installation & Usagepip installInstall themanticoresearchpackage withpippipinstallmanticoresearchThen import the package:importmanticoresearchSetuptoolsInstall viaSetuptools.pythonsetup.pyinstall--user(orsudo python setup.py installto install the package for all users)Then import the package:importmanticoresearchGetting StartedPlease follow theinstallation procedureand then run the following:from__future__importprint_functionimporttimeimportmanticoresearchfrommanticoresearchimport*frommanticoresearch.restimportApiExceptionfrompprintimportpprint# Defining the host is optional and defaults to http://127.0.0.1:9308# See configuration.py for a list of all supported configuration parameters.configuration=manticoresearch.Configuration(host="http://127.0.0.1:9308")# Enter a context with an instance of the API clientwithmanticoresearch.ApiClient(configuration)asapi_client:# Create an instance of the IndexApi API classapi_instance=manticoresearch.IndexApi(api_client)body="["'{\"insert\": {\"index\":\"test\",\"id\": 1,\"doc\": {\"title\":\"Title 1\"}}},\\n{\"insert\": {\"index\":\"test\",\"id\": 2,\"doc\": {\"title\":\"Title 2\"}}}'"]"# str |try:# Bulk index operationsapi_response=api_instance.bulk(body)pprint(api_response)exceptApiExceptionase:print("Exception when calling IndexApi->bulk:%s\n"%e)# Create an instance of the Search API classapi_instance=manticoresearch.SearchApi(api_client)# Create SearchRequestsearch_request=SearchRequest()search_request.index='test'search_request.fullltext_filter=QueryFilter('Title 1')# The example passes only required values which don't have defaults settry:# Perform a searchapi_response=api_instance.search(search_request)pprint(api_response)exceptmanticoresearch.ApiExceptionase:print("Exception when calling SearchApi->search:%s\n"%e)DocumentationFull documentation on the API Endpoints and Models used is available indocsfolder as listed below.Manticore Search server documentation:https://manual.manticoresearch.com.
Package: manticoresearch-dev
Manticore Python clientСlient for Manticore Search.Requirements.Minimum Manticore Search version is >= 2.5.1 with HTTP protocol enabled.Installation & Usagepip installInstall themanticoresearchpackage withpippipinstallmanticoresearch-devThen import the package:importmanticoresearchSetuptoolsInstall viaSetuptools.pythonsetup.pyinstall--user(orsudo python setup.py installto install the package for all users)Then import the package:importmanticoresearchGetting StartedPlease follow theinstallation procedureand then run the following:from__future__importprint_functionimporttimeimportmanticoresearchfrommanticoresearchimport*frommanticoresearch.restimportApiExceptionfrompprintimportpprint# Defining the host is optional and defaults to http://127.0.0.1:9308# See configuration.py for a list of all supported configuration parameters.configuration=manticoresearch.Configuration(host="http://127.0.0.1:9308")# Enter a context with an instance of the API clientwithmanticoresearch.ApiClient(configuration)asapi_client:# Create an instance of the IndexApi API classapi_instance=manticoresearch.IndexApi(api_client)body="["'{\"insert\": {\"index\":\"test\",\"id\": 1,\"doc\": {\"title\":\"Title 1\"}}},\\n{\"insert\": {\"index\":\"test\",\"id\": 2,\"doc\": {\"title\":\"Title 2\"}}}'"]"# str |try:# Bulk index operationsapi_response=api_instance.bulk(body)pprint(api_response)exceptApiExceptionase:print("Exception when calling IndexApi->bulk:%s\n"%e)# Create an instance of the Search API classapi_instance=manticoresearch.SearchApi(api_client)# Create SearchRequestsearch_request=SearchRequest()search_request.index='test'search_request.fullltext_filter=QueryFilter('Title 1')# The example passes only required values which don't have defaults settry:# Perform a searchapi_response=api_instance.search(search_request)pprint(api_response)exceptmanticoresearch.ApiExceptionase:print("Exception when calling SearchApi->search:%s\n"%e)DocumentationFull documentation on the API Endpoints and Models used is available indocsfolder as listed below.Manticore Search server documentation:https://manual.manticoresearch.com.
Package: mantik
mantik - plugin for MLflow with HPC (UNICORE)Mantik allows to manage the full Machine Learning workflow on HPC by
supporting MLflow and deployment of applications to HPC.For a quickstart seeour documentationExtra DependenciesBy default, mantik only installs the core dependencies required to use the Mantik API.
However, additional extras are provided and can be installed:mlflow: installs the supported MLflow version (i.e.mlflow-skinnydue do its much smaller size compared tomlflow)pipinstall"mantik[mlflow]"s3: installs the required dependencies to use theS3 Remote File Servicepipinstall"mantik[s3]"unicore: installs the required dependencies to use theUNICORE Remote File Servicepipinstall"mantik[unicore]"docker: installs the required dependencies to use the Model Docker imagespipinstall"mantik[docker]"HelpdeskFor bug reports or feature requests, please email our helpdesk.
Details can be foundhere.
Package: mantisconnect2
Notesforkeds from mantisconnect-python project(author:morenice)update to support mantis 2.x (mantisconnect-python only supports 1.x)support python 2.7more features,eg add new issue etcPython client for Mantis Connect SOAP APIIt is good to request issue data on a filter basis.You can use extended fields as well as custom fields.Offers simple interface.UsageSee sample/sample.pymc = MantisSoapConnector("url")
mc.set_user_passwd("username", "password")
mc.connect()

p = SimpleProject(mc, "your project name")
filter_name = "your filter name"
issue_list = p.request_filter_all_issues(filter_name)InstallRequirementpython 2.7 , 3.xzeep$ pip install mantisconnect2Test versionmantis 1.2.11, 2.18
Package: mantisshrimp
MantisShrimpMantisShrimp is in very early development, all contributions are welcome! Be sure to check theissuesboard =)Built on top ofpytorch-lightining,MantisShrimpis an object detection framework focused on applicationMantisshrimp provides aDataParserinterface that simplifies the time consuming task of getting the data ready for the model, aTfminterface that makes it real easy to add any transforms library to the data pipeline, and a mid and a high level interface for training the model.Installpipinstall-U'git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI'pipinstallgit+git://github.com/lgvaz/mantisshrimp.gitQuick startCheckthistutorial file for a quick introduction.Be sure to also check other examples in theexamples/folder.
Package: mantis-xray
SpectromicroscopySpectromicroscopycombines spectral data with microscopy,
where typical datasets consist of a stack of microscopic images
taken across an energy range. Due to the data complexity, manual analysis
can be time consuming and inefficient, whereas multivariate analysis tools
not only reduce the time needed but also can uncover hidden trends in the data.MantisMANTiSis Multivariate ANalysis Tool for Spectromicroscopy developed in Python by2nd Look Consulting. It uses principal component analysis and cluster analysis to classify pixels according to spectral similarity.DownloadMantis package and binaries can be downloaded fromspectromicroscopy.com.
Alternatively, you can installPythonand then run the command:python3 -m pip install mantis-xrayUpdateYou can upgrade to the latest package release with the command:pip3 install mantis-xray -U.
It is recommended that you also upgrade the dependencies with:pip3 install mantis-xray -U --upgrade-strategy "eager"RunInstallation via pip provides themantis-xraycommand (alternativelypython3 -m mantis_xray) to start the Mantis GUI.User GuideMantis User Guide can be found on the project Wiki pagesHome.ReferencesPlease use the following reference when quoting MantisLerotic M, Mak R, Wirick S, Meirer F, Jacobsen C. MANTiS: a program for the analysis of X-ray spectromicroscopy data. J. Synchrotron Rad. 2014 Sep; 21(5); 1206–1212 [http://dx.doi.org/10.1107/S1600577514013964]
Package: mantium-client
Mantium ClientA Python client library forMantiumservices.PrerequisitesBefore you start working with this client, there are a few steps you need to complete. These prerequisites will help ensure that you can seamlessly interact with Mantium's functionalities.1. Request Beta AccessFirstly, you need to sign up for beta access.
Visit theMantium Beta Signuppage,
fill in the necessary details, and submit your form to request beta access.
Once your request has been approved, you'll be granted access to create an account
and explore Mantium's extensive range of features.2. Create an ApplicationAfter creating an account and logging in, your next step is to create an application.
Mantium offers a variety of pre-made templates to simplify this process.
For example, you might choose the Recipe Management template.When you create an application from a pre-made template, two key steps will occur:You will upload files or connect to a data source such as Notion or Slack. This is where the application will pull content from.The content provided by you will be pre-processed, vectorized, and then stored in a Redis vector database.After performing these steps, you can engage with your data in a meaningful way through the application you've just created.3. Enable API AccessFrom your dashboard or main menu, locate and click on the User Profile section.Within your user profile, there's an option to enable Python Client Access. This step is vital as it unlocks the interface that the client will use to communicate with your application:4. Client ID and Client SecretUpon enabling API access, Mantium will present a Client ID and Client Secret. These unique identifiers authenticate your client's requests to the Mantium application. Please record them carefully. You will need to use them with the MantiumClient, as shown in the Usage section below.InstallationUse the package managerpipto install this client.pipinstallmantium-clientUsagefrommantium_spec.api.applications_apiimportApplicationsApifrommantium_client.api_clientimportMantiumClientclient=MantiumClient(client_id=client_id,client_secret=client_secret)apps_api=ApplicationsApi(client)# returns a list of applicationsapps_api.list_applications()# returns an application's detailsapps_api.get_application_detail(application_id)# query an applicationquery_request={'query':'What should I have for dinner tonight?'}returnapps_api.query_application(application_id,query_request)Available API EndpointsPlease see the PyPI-hostedmantium-specpackage for details on API endpoints available through the ApplicationsApi class.LicenseApache-2.0DevelopmentThis is only necessary if you want to develop in this project.We usepoetryfor dependency management.pipinstallpoetry
poetryinstall--withdev,test--verbose
Package: manual
manualPython interfaces to system callsTo install:pip install manualExamplesWrite some "instructions" for someone with some placeholders like so:template="""git checkout{main_branch}git pullgit checkout{to_merge_branch}git merge{main_branch}git push"""Then just make a function like this:ri=mk_command_runner(template)Thenriis a function with a nice signature with arguments to control the
placeholders.frominspectimportsignatureassertstr(signature(ri))=='(main_branch, to_merge_branch, *, _dry_run=False)'If you call the function, it will run the commands one by one, printing
the command it's about the run and then the output of the run.
The_dry_runallows one to just do the command prints without actually running
the commands:print(ri('master','fixing_something',_dry_run=True))(1/5)$ git checkout master

(2/5)$ git pull

(3/5)$ git checkout fixing_something

(4/5)$ git merge master

(5/5)$ git pushNote that you can also specify your commands as a list,
and also ask that the commands be run one by one, asking the user to
type any key to continue at every step:pwd_and_ls=mk_command_runner(["pwd","ls -l"],step_by_step=True)pwd_and_ls()(1/2)$ pwd
/Users/Thor.Whalen/Dropbox/dev/p3/proj/t/manual

TYPE ANY KEY TO CONTINUE

(2/2)$ ls -l
total 48
-rw-r--r--@ 1 Thor.Whalen  staff  11357 Jun 15 21:00 LICENSE
-rw-r--r--@ 1 Thor.Whalen  staff   1040 Jun 15 21:13 README.md
drwxr-xr-x@ 9 Thor.Whalen  staff    288 Jun 15 21:00 docsrc
drwxr-xr-x@ 5 Thor.Whalen  staff    160 Jun 15 21:04 manual
-rw-r--r--@ 1 Thor.Whalen  staff    422 Jun 15 21:04 setup.cfg
-rw-r--r--@ 1 Thor.Whalen  staff     91 Jun 15 21:00 setup.pyWhere this is goingHow many times do we write instructions for others, or ask others for us.
Or perhaps we're even organized enough to have a little file where
we put our little how-to recipes, commenting them with natural language
so we can understand what the steps are, and simply be able to
find those instructions when the time comes.And then we go through those commands one by one, making sure we replace the
right part of the instructions with the right values for our context,
maybe trying to read the comments, so we know what we're doing.Really though, we no extra effort but following some convention to
make our instructions parsable,
we can make our instructions, well, executable.So instead of this:git checkout {your_main_branch}
git pull
git checkout {your_branch}
git merge {your_main_branch}
# Now resolve conflics and press any key when ready for the next step
git commit -m {your_commit_message}
git pushjust being that, we can take it as a DSL that will also give us:A function that does it allA function that will actually guide the user through the steps,
explaining what's happening etc. (so also educational)This means that we can then REUSE something like a markdown document
that explains recipes, installation instructions, etc.
also as boilerplate-less utils.
Package: manualindex
manualindexGenerate autoindex-style HTML for your directory listings.InstallpipinstallmanualindexOr if you're using poetry:poetryaddmanualindexManualindex supports Python 3.9 and above.UsageManualindex can be used both as a library and as a command-line program.CLIpython-mmanualindex/path/to/dirA Jinja template is used to generate theindex.htmlfiles. To customise the template, you'll need to pass two flags:python-mmanualindex/path/to/dir--template-path/path/to/templates--template-namemytemplate.html.j2For this example to work, there must be a file namedmytemplate.html.j2inside/path/to/templates.Due to how the URL generation works, if your directory listings are not at the root of your domain, you'll need to pass
the base URL path. For example, if your base URL ishttps://example.com/mydir/mysubdir/, you will need the following:python-mmanualindex/path/to/dir--base-urlpath/mydir/mysubdir/You can customise the date format:python-mmanualindex/path/to/dir--date-format'%Y-%m-%d'The default date format is%Y-%m-%d %H:%I.To customise the timezone of the formatted timestamps:python-mmanualindex/path/to/dir--timezoneAustralia/MelbourneThe default timezone is UTC.LibraryTo make use of all the defaults:frompathlibimportPathfrommanualindeximportgenerate_defaultgenerate_default(Path("/path/to/dir"))To customise the template generation options, but use the default template:frompathlibimportPathfrommanualindeximportdefault_template,generategenerate(Path("/path/to/dir"),default_template,base_urlpath="/mydir/mysubdir/",date_format="%Y-%m-%d",date_tz="Australia/Melbourne",)The second parameter togenerate()accepts any JinjaTemplateobject, so you have full control over the output.
Manualindex makes no assumptions about where the template comes from.LicenseThe code is available under theGPL Version 3.
Package: manual-sitemap
IntroductionNowadays, SPA (Single Page Application) Websites usingVue,ReactandAngularare booming. But, for those SPA websites, creating sitemap is not easy task for considering all uri query string and uri parameters. This module helps create sitemap manually usingpythonfile where we define urls, and query strings.Installationpip installmanual-sitemapNoteIt might be good using virtualenv tools such asvirtualenvandpipenvto protect your root python and avoid dependency issue.ExampleMake config.py and setDOMAIN,ROUTESandQUERIES(optional).# config.pyDOMAIN='https://example.com'# (route, [querie string keys])# queries must be emtpy list if it has no query strings.ROUTES=[('/exercise',['page','date']),('/homework',['date']),]# { query string key: [query string values ]}QUERIES={'page':[1,2,3,4,5,6,7,8,9,10],'date':['2019-01-01','2019-04-03','2019-04-08','2019-05-06']}Manual-sitemap can be easily run usingmanual-sitemap$ manual-sitemap configNoteRemove.pyat the end of configYou can change output filename using--outputkeyword
Package: manuelpi.fakemodule
A plugin to enable the definition and usage of whole
Python modules from within doctests.Intro and Motivationmanuelpi.fakemoduleis a plugin forManuelthat supports syntax
for creating modules within a doctest. The module, once defined, is then
usable by subsequent doctest statements.This functionality is useful for packages that you might describe as
being ‘meta’; they operate on modules. Thus, being able to define
and then process modules within the same doctest using a clean and
uncluttered syntax is extremely beneficial.One such package to benefit from this sort of facility isMartian,
which scans modules for configuration directives, registering them as
it goes.UsageThe special REStructure Text directive:'.. module-block:: <MODULE_NAME>'is used to denote the start of a module and its alias <MODULE_NAME> for
the rest of the doctest. We then define the module’s body at a single
indentation level after this directive. What follows is an example of a
full doctest:We create a new module with a main function to perform this task::

.. module-block:: test_module

   import sys

   class A:
       def do_something(self):
           return "Hello World"

   def main():
       print A().do_something()

 Now let's execute the main function>>> test_module.main()
Hello WorldThe above doctest creates a new moduletest_moduleand then exercises
the objects within it. Notice how the module becomes immediately available
to the doctet after its definition.To usemanualpi.fakemodulein your application, set up your tests as
described in the Manuel documentation and import theManuelclass frommanuelpi.fakemodule:...
import manuelpi.fakemodule
...
m += manuelpi.fakemodule.Manuel()CHANGES0.1b1 (2009-12-16)Initial Public Release