Saravanan666/pypi-org huggingface dataset:
Package: minitds
Yet another Python MS SQLServer database driver.Support platformPython 3.5+Support databaseWe test with MS SQLServer 2019 on Ubuntu.
But we think it works with the following versions.MS SQLServer 2012, 2014, 2016, 2017, 2019Microsoft Azure SQL DatabaseInstallation$ pip install minitdsExampleQuery:import minitds
conn = minitds.connect(host='localhost',
                    user='sa',
                    password='secret',
                    database='database_name')
cur = conn.cursor()
cur.execute('select foo, bar from baz')
for r in cur.fetchall():
   print(r[0], r[1])
conn.close()Execute Procedure:import minitds
conn = minitds.connect(host='localhost',
                    user='sa',
                    password='secret',
                    database='database_name')
cur = conn.cursor()
cur.callproc('something_proc', [123, 'ABC'])
conn.close()RestrictionsSupport connecting through SQL Server Authentication only.
Package: minitf
Copyright (c) 2020 Michael MiAll contributions by Google:
Copyright (c) 2020, Google, Inc.
All rights reserved.All other contributions:
Copyright (c) 2020, the respective contributors.
All rights reserved.Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.Description: # minitf: Simplified version of Tensorflow.[![Build Status](https://travis-ci.com/guocuimi/minitf.svg?branch=master)](https://travis-ci.com/guocuimi/minitf)
[![Coverage Status](https://coveralls.io/repos/github/guocuimi/minitf/badge.svg?branch=master)](https://coveralls.io/github/guocuimi/minitf?branch=master)Keywords: Deep learning,Tensorflow,Autodiff,Backpropagation,Gradients,Neural networks,Python,Numpy
Platform: UNKNOWN
Classifier: Development Status :: 2 - Pre-Alpha
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Package: minitk
minitkMinimalist non blocking control panel for parametersInstallationsudo apt install python3-tk
pip install minitkUsageHere is a simple example:import minitk

def say_hello():
    print('hello')

control_panel = minitk.ControlPanel()
control_panel.create_button('Say hello', say_hello)
control_panel.create_check_button('Status')
control_panel.create_slider('Value', 0, 10)
control_panel.create_menu('Options', ['a', 'b', 'c'])

while True:
    control_panel.update()More examples are available under examples/
Package: minitrade
Minitrade - Simplifying Personal TradingMinitradeis a personal trading system that combines strategy backtesting and automated order execution. Leveraging the power ofBacktesting.py, Minitrade offers an array of enhanced features:Multi-asset rebalancing strategy backtest: Explore and optimize your trading strategies across various assets.Automated strategy execution and order submission: Seamlessly execute your trading strategies and submit orders automatically.Web-based management UI: Access a user-friendly web interface to manage and monitor your trading activities.Streamlined mobile notifications and control: Stay informed and in control with mobile notifications for important trading events.With Minitrade, setting up your private and fully automated stock trading system is easy and affordable.Installation$ pip install minitrade
$ minitrade initMinitrade requirespython >= 3.10."minitrade init"is only necessary if you use Minitrade for trading. Run it again after every Minitrade upgrade. For detailed installation instructions, refer to theInstallationsection on the website.UsageBacktestingTradingSee more inDocumentation.LimitationsPlease be aware of the following limitations:Multi-asset strategies currently support long positions and market orders only.Minitrade has been tested on Linux platforms.Daily bar data is currently supported.Interactive Brokers is the supported broker.ContributingCheck out the guidelines onhow to contributeto the project.LicenseAGPL-3.0
Package: mini-trainer
Mini Trainer for PyTorchThis is a mini Trainer for PyTorch ecosystem. Particularly suitable for research and experiments because of the following advantages:Fully transparent and retraceable training processLow code volume for easy debuggingMeets the main requirements for model training and evaluatingMain features:Pipeline for model training and evaluatingCheckpointEarlystoppingLogging based on json fileInstallationpipinstallmini-trainerQuick StartBelow is two examples for starting using mini-trainer. First is classic image classification task and another is house price regression. Both of them are complete deep learning project, and you can learn how the basic usage and main APIs of this project.MINST ClassificationHouse Sale Price PredictionMain Functions and APIsInitialization: Trainer()APITypeDescmodelnn.ModuleA model object to train.save_pathstrPath to save checkpoints/loss plot/log file/etc.optimizertorch.optim.optimizerOptimizer class, default AdamlrfloatLearning rate, default1e-3losscallableLoss function, defaultL1 lossdevicestrDevice type, default"auto". ["auto", "cpu", "cuda"]early_stoppingboolWhether early stopping, default Truestop_patienceintStop patience, default7stop_modestrStop mode. For example, if you use MSE to test you model,  this argument should be "min" while this should be "max" for Accuracy. default"min"Model Training: fit()APITypeDesctrain_dataloadertorch.utils.data.DataLoaderTraining dataloader.val_dataloadertorch.utils.data.DataLoaderValidation dataloader.epochsintNumber of epochs, default50prog_barboolWhether display progress bar to monitor training process, defaultTruePredicting: predict()APITypeDesctest_dataloadertorch.utils.data.DataLoaderDataloader.Result saving: log()APITypeDesclogdictAnything you want to record to log file, saved as a dictionary. It is very useful for research experiments in which you can record experiment start time, version, key hyperparameters, etc.Plot loss curve: plot_loss()APITypeDescsaveboolWhether to save loss plot.
Package: minitrue
minitrue is a proxy designed to lie.It does this by mangling the requests sent by the client before forwarding
them to the remote server, and mangling the responses sent by the server
before relaying them back to the client.Note that this is little more than a proof of concept. If you want to do this
to any amount of traffic, there are better alternatives, such asicapin
combination with a proxy server such asSquid.WAR IS PEACELike so many other tools, there are evil use cases for this tool. What you use
it for is entirely up to you.FREEDOM IS SLAVERYThe code is available under the very permissiveISC license.  Contribution
is welcomed through theGithub project page.IGNORANCE IS STRENGTHThis project doesn’t come with a lot of documentation yet. Maybe, one day,
some documentation will be written. If you want to use it right now, the test
suite is a good place to start.
Package: miniuri
miniuri is a universal URI parser class.Only 145 lines of Python (400 lines if you count unit tests).InstallationpipinstallminiuriWhat does it do?The parser grants access to the following attributes:foo://username:password@test.com:808/go/to/index.php?pet=cat&name=bam#eye
\_/   \_______________/ \______/ \_/       \___/ \_/ \_______________/\_/
 |           |             |      |          |    |       |            |
 |       userinfo       hostname  |          |    |      query   fragment
 |    \___________________________|/\________|____|_/
 |                  |             |      |   |    |
scheme          authority         |    path  |  extension
                                  |          |
                                 port     filenameTutorialThis example shows how you can set and get any of the URI attributes:>>>fromminiuriimportUri>>>u=Uri("http://www.foxhop.net/samsung/HL-T5087SA/red-LED-failure")>>>u.uri="https://fox:pass@www.foxhop.net:81/path/filename.jpg?p=2#5">>>print(u.uri)'https://fox:pass@www.foxhop.net:81/path/filename.jpg?p=2#5'>>>print(u.hostname)'www.foxhop.net'>>>print(u.scheme)'https'>>>u.username='max'>>>print(u)'https://max:pass@www.foxhop.net:81/path/filename.jpg?p=2#5'>>>print(u.relative_uri)'/path/filename.jpg?p=2#5'How do I thank you?You should follow me onhttp://twitter.com/russellbalLicensePublic DomainPublic Revision Controlhttps://git.unturf.com/python/miniuri
Package: miniutils
OverviewFull documentation for this module is available over atReadTheDocs.This module provides numerous helper utilities for Python3.X code to add functionality with minimal code footprint. It has tools for the following tasks:Progress bars on serial loops and parallel mappings (leveraging the excellenttqdmlibrary)Simple lazy-compute and caching of class properties, including dependency chainingExecuting Python2 code from within a Python3 programMore intuitive contract decorator (leveragingpycontracts)InstallationAs usual, you can install the latest code version directly from Github:pip install git+https://github.com/scnerd/miniutilsOr you canpipinstall the latest release from PyPi:pip install miniutilsExamplesTo get started, you can import your desired utilities directly fromminiutils. For example, to use theCachedPropertydecorator:from miniutils import CachedProperty

class MyClass:
   @CachedProperty
   def attribute(self):
      return some_slow_computation(self)Or to use the progress bar utilities:from miniutils import progbar, parallel_progbar

def mapper(x):
   return x**2

assert [mapper(i) for i in progbar(100)] == parallel_progbar(mapper, range(100))To see documentation for each feature, look through this documentation or the table of contents above.
Package: miniver
MiniverLikeversioneer, but smallerMiniver is aminimalversioning tool that serves the same purpose
asVersioneer, except that it only works with Git and
multiplatform support is still experimental.Why would I use this?If you are developing a Python package inside a Git repository and
want to get the version directly from Git tags, rather than hard-coding
version strings everywhere.This is the same problem that Versioneer solves, but Miniver is less
than 200 lines of code, whereas Versioneer is over 2000. The tradeoff
is that Miniver only works with Git and Python 3.5 (or above).Support for Python 2 is not a goal, as Python 2 is fast approaching its
end of life (2020), and we want to encourage people to use Python 3!
That being said, Christian Marquardt has afork that also
works with Python 2UsageThe simplest way to use Miniver is to run the following in your project root:curl https://raw.githubusercontent.com/jbweston/miniver/master/miniver/app.py | python - install <your_package_directory>This will grab the latest files from GitHub and set up Miniver for your project.I get anunknownversion!The version is reported asunknown(plus the current git hash) when there are no valid tags
in the git history. You should create anannotated tagso that Miniver reports a reasonable version.If your project usesunannotated tagsfor versioning (though this is not therecommended way)
then you'll need to run the following in order to modify Miniver's behaviour:curl https://raw.githubusercontent.com/jbweston/miniver/master/unannotated-tags.patch | patch <your_package_directory>/_version.pyI don't want to type that URL every time I use thisYou canpip install miniver, which will give you theminivercommand.
Then you can simply run the following from your project root to use Miniver:miniver install <your_package_directory>Can I use this without executing random code from the internet?Sure! Copyminiver/_version.pyandminiver/_static_version.pyfrom this
repository into your package directory, then copy the following snippets into
the appropriate files:# Your package's __init__.pyfrom._versionimport__version__del_version# Your project's setup.pyfromsetuptoolsimportsetup# Loads _version.py module without importing the whole package.defget_version_and_cmdclass(pkg_path):importosfromimportlib.utilimportmodule_from_spec,spec_from_file_locationspec=spec_from_file_location('version',os.path.join(pkg_path,'_version.py'),)module=module_from_spec(spec)spec.loader.exec_module(module)returnmodule.__version__,module.get_cmdclass(pkg_path)version,cmdclass=get_version_and_cmdclass('my_package')setup(name='my_package',version=version,cmdclass=cmdclass,)# Your project's .gitattributes
my_package/_static_version.py export-substreplacing'my_package'in the above with the name of your package
(this should be the same as the name of the directory into
which you copied the contents ofminiver).That's it!LicenseMiniver is in the public domain under a CC0 license.
Package: mini-vk
Mini_VKA  module Python, small wrapper over the VK APIInstallationTo install the latest release on PyPI, simply run:pip install mini-vkOr to install the latest development version, run:pip install git+https://github.com/SemenovAV/mini_vkQuick Tutorialapi.get_apitakes in a string containing access token vkfrommini_vk.apiimportget_apiapi=get_api(access_token)response=api.users.get(user_id=1).textresponse:{"response":[{"id":1,"first_name":"Павел","last_name":"Дуров","is_closed":false,"can_access_closed":true}]}
Package: mini-vss
MiniVSS(Version Sharing System)Share your software versions to end users securely and easy!How it is done?Maintainer creates repository with compiled (now only onefile) program versionsEvery version is signing with private keyGenerated folder loads to web-serverServer URL and public key are sharing inside appUsers download versions from serverAfter signature checking user`s program is replaced with new oneInstallationYou can install MiniVSS from PyPI:python -m pip install mini-vssUsageMaintain simple repository:$cdAPP_FOLDER# Create .vss folder with all needed maintainer staff$mini_vssinit--remoteSERVER_URL#  Platform - independent version pack for specific end user configurations$mini_vssadd_platformPLATFORM_NAMEPLATFOM_COMPILED_FILE_PATH# Fix current compiled file as version$mini_vssfixVERSION_NAME# Review all platfroms and versions$mini_vssshow# Creates client_config.py which should be used by client app$mini_vssgenerate_client_config

$rsync-a.vss/platforms/SERVER_PATH# or any other way to copy your`s platforms to serverFor further configurations directly use.vss/conf.jsonDeveloping is in process :sweat_smile:Client upgrading example:importmini_vssimportclient_configv_client=mini_vss.VSSClient(client_config.PLATFORM_CONFIG)v.client.upgrade_to_latest()
Package: miniwdl-aws-studio
miniwdl + GWFCore + SageMaker StudioThis repository is a recipe for deployingminiwdl-awsandGWFCoreto use withinAmazon SageMaker Studio, a web IDE with a terminal and filesystem browser. You can use the terminal to operateminiwdl runagainst GWFCore's AWS Batch stack, the filesystem browser to manage the inputs and outputs on EFS, and the Jupyter notebooks to further analyze the outputs.CDK boilerplateThecdk.jsonfile tells the CDK Toolkit how to execute your app.This project is set up like a standard Python project.  The initialization
process also creates a virtualenv within this project, stored under the.venvdirectory.  To create the virtualenv it assumes that there is apython3(orpythonfor Windows) executable in your path with access to thevenvpackage. If for any reason the automatic creation of the virtualenv fails,
you can create the virtualenv manually.To manually create a virtualenv on MacOS and Linux:$ python3 -m venv .venvAfter the init process completes and the virtualenv is created, you can use the following
step to activate your virtualenv.$ source .venv/bin/activateIf you are a Windows platform, you would activate the virtualenv like this:% .venv\Scripts\activate.batOnce the virtualenv is activated, you can install the required dependencies.$ pip install -r requirements.txtAt this point you can now synthesize the CloudFormation template for this code.$ cdk synthTo add additional dependencies, for example other CDK libraries, just add
them to yoursetup.pyfile and rerun thepip install -r requirements.txtcommand.Useful commandscdk lslist all stacks in the appcdk synthemits the synthesized CloudFormation templatecdk deploydeploy this stack to your default AWS account/regioncdk diffcompare deployed stack with current statecdk docsopen CDK documentationEnjoy!
Package: miniwdl-s3parcp
miniwdl-s3parcpThis Python package is aMiniWDLplugin to handle S3 download (localization)
and upload (delocalization) tasks for S3 URIs in WDL workflow I/O, usings3parcp.Installationpip3 install miniwdl-s3parcpTo check that the installation was successful, runminiwdl --version, which will list available plugins, including this one.UsageThe plugin will automatically be used to handles3://bucket/keyURIs found in workflow inputs.
Package: miniwdl-s3upload
miniwdl-s3uploadThis Python package is aMiniWDLplugin to handle the orchestration of S3 upload (delocalization) for S3 URIs in WDL workflow I/O.Installationpip3 install miniwdl-s3uploadTo check that the installation was successful, runminiwdl --version, which will list available plugins, including this one.UsageSet the environment variableMINIWDL__S3_PROGRESSIVE_UPLOAD__URI_PREFIXto an S3 URL where the task outputs should be uploaded.
Package: miniwdl-slurm
Extends miniwdl to run workflows on SLURM clusters in singularity containers.ThisSLURM backendplugin forminiwdlruns WDL task containers
by creating a job script that is submitted to a SLURM cluster. In case the job
description has a container, singularity will be used as container runtime.InstallationFor the latest stable version:pip install miniwdl-slurmFor the development version:pip install git+https://github.com/miniwdl-ext/miniwdl-slurm.gitConfigurationThe followingminiwdl configurationexample can be used to use miniwdl on a SLURM cluster:[scheduler]container_backend=slurm_singularity# task_concurrency defaults to the number of processors on the system.# since we submit the jobs to SLURM this is not necessary.# higher numbers means miniwdl has to monitor more processes simultaneously# which might impact performance.task_concurrency=200# This setting allows running tasks to continue, even if one other tasks fails.# Useful in combination with call caching. Prevents wasting resources by# cancelling jobs half-way that would probably succeed.fail_fast=false[call_cache]# The following settings create a call cache under the current directory.# This prevents wasting unnecessary resources on the cluster by rerunning# jobs that have already succeeded.put=trueget=truedir="$PWD/miniwdl_call_cache"[task_runtime]# Setting a 'maxRetries' default allows jobs that fail due to intermittent# errors on the cluster to be retried.defaults={"maxRetries":2,"docker":"ubuntu:20.04"}[singularity]# This plugin wraps the singularity backend. Make sure the settings are# appropriate for your cluster.exe=["singularity"]# the miniwdl default options contain options to run as a fake root, which# is not available on most clusters.run_options=["--containall"]# Location of the singularity images (optional). The miniwdl-slurm plugin# will set it to a directory inside $PWD. This location must be reachable# for the submit nodes.image_cache="$PWD/miniwdl_singularity_cache"[slurm]# extra arguments passed to the srun command (optional).extra_args="--partition heavy_users,gpu --comment 'run with miniwdl'"
Package: miniwob
The MiniWoB++ (Mini World of Bits++) library contains a collection of over 100web interaction environments,
along with JavaScript and Python interfaces for programmatically interacting with them.
The Python interface follows theGymnasiumAPI
and usesSelenium WebDriverto perform actions on the web browser.MiniWoB++ is an extension of theOpenAI MiniWoB benchmark,
and was introduced in the paperReinforcement Learning on Web Interfaces using Workflow-Guided
Exploration.The documentation website is atminiwob.farama.org.
Development on MiniWoB++ is currently ongoing to bring it up toFarama Standardsfor mature projects, and will be maintained long term after this point. See theProject Roadmapfor more details. If you'd like to help out, you can join our discord server here:https://discord.gg/PfR7a79FpQ.InstallationMiniWoB++ supports Python 3.8+ on Linux and macOS.Installing the MiniWoB++ LibraryTo install the MiniWoB++ library, usepip install miniwob.Installing Chrome/Chromium and ChromeDriverWe strongly recommend using Chrome or Chromium as the web browser,
as other browsers may render the environments differently.The MiniWoB++ Python interface usesSelenium,
which interacts with the browser via theWebDriver API.
Follow one of theinstruction methodsto install ChromeDriver. The simplest method is todownloadChromeDriver with the matching version,
unzip it, and then add the directory containing thechromedriverexecutable to thePATHenvironment variable:exportPATH=$PATH:/path/to/chromedriverFor Chromium, the driver may also be available in a software package; for example, in Debian/Ubuntu:sudoaptinstallchromium-driverExample UsageThe following code performs a deterministic action on theclick-test-2environment.importtimeimportgymnasiumfromminiwob.actionimportActionTypesenv=gymnasium.make('miniwob/click-test-2-v1',render_mode='human')# Wrap the code in try-finally to ensure proper cleanup.try:# Start a new episode.obs,info=env.reset()assertobs["utterance"]=="Click button ONE."assertobs["fields"]==(("target","ONE"),)time.sleep(2)# Only here to let you look at the environment.# Find the HTML element with text "ONE".forelementinobs["dom_elements"]:ifelement["text"]=="ONE":break# Click on the element.action=env.unwrapped.create_action(ActionTypes.CLICK_ELEMENT,ref=element["ref"])obs,reward,terminated,truncated,info=env.step(action)# Check if the action was correct.print(reward)# Should be around 0.8 since 2 seconds has passed.assertterminatedisTruetime.sleep(2)finally:env.close()Seethe documentationfor more information.EnvironmentsThe list of the environments that were included in the MiniWoB++ library can be found in thedocumentation.
All environments share the sameobservation space,
while theaction spacecan be configured during environment construction.CitationTo cite this project please use:@inproceedings{liu2018reinforcement,author={Evan Zheran Liu and Kelvin Guu and Panupong Pasupat and Tianlin Shi and Percy Liang},title={Reinforcement Learning on Web Interfaces using Workflow-Guided Exploration},booktitle={International Conference on Learning Representations ({ICLR})},url={https://arxiv.org/abs/1802.08802},year={2018},}