Saravanan666/pypi-org huggingface dataset:
Package: pdm-multirun
PDM MultirunAPDMplugin to run a command on multiple Python versions.InstallationWithpipx:pipxinstallpdm
pipxinjectpdmpdm-multirunWithPDM:pdmselfaddpdm-multirunAs a local-only plugin:# pyproject.toml[tool.pdm]plugins=["pdm-multirun",]pdminstall--pluginsUsageThis plugin adds amultiruncommand to PDM.
The command accepts the same parameters as theruncommand,
with an additional-i,--interpreters,--versionsparameter
that allows to specify the interpreters to use.pdmmultirunpytesttests/To specify interpreters, pass a comma-separated string
of Python versions:pdmmultirun-i3.10,3.11pytesttests/If you use virtual environments instead,
pass their names to the--interpretersoption
and add the-e,--venvsflag:pdmmultirun-ei3.10,3.11pytesttests/pdmmultirun-eitests38,tests39pytesttests/You can set PDM Multirun to use virtual environments by default by
setting thePDM_MULTIRUN_USE_VENVSenvironment variable to1.By default, PDM Multirun reads Python versions (or venv names)
from thePDM_MULTIRUN_VERSIONSenvironment variable.
It is a string of{major}.{minor}versions (or venv names),
separated by spaces, that can be found and called by PDM.exportPDM_MULTIRUN_VERSIONS="3.8 3.9 3.10 3.11 3.12"pdmmultirunpytesttests/exportPDM_MULTIRUN_VERSIONS="tests38 tests39 tests310"pdmmultirunpytesttests/PDM Multirun sets a number of environment variables that can be used by code run
in each version.PDM_MULTIRUNset to1whenever PDM Multirun is being used.PDM_MULTIRUN_CURRENTis set to the name of the current interpreter or
virtual environment (such as that passed using-iorPDM_MULTIRUN_VERSIONS).You can use these variables, for example, to output metadata about the current
Python version or interpreter, like in the example below, which if invoked by
PDM Multirun, would start by printing the name of the virtual environment or
interpeter, and the version of Python being used.script.pyimportosimportsysMULTIRUN=os.getenv("PDM_MULTIRUN","0")=="1"ifMULTIRUN:int_name=os.getenv('PDM_MULTIRUN_CURRENT','')py=f"{int_name}:{sys.version_info[0]}.{sys.version_info[1]}"print(f"{py}- Hello from python! 👋")# continue script as required...In a scenario where you had two virtual environments,tests38andtests39,
and saved this script in a file namedexample.py, running the command:pdm multirun -e tests38,tests39 python example.pyWould output the text below.tests38: 3.8 - Hello from python! 👋
tests39: 3.9 - Hello from python! 👋PDM Multirun successively runs thepdm usethenpdm runinternal actions.
By default, if PDM cannot "use" an interpreter/venv, it continues with the next.# will continue with 3.8 even if 3.7 is not availablepdmmultirun-i3.7,3.8pytesttests/You can tell it to fail instead with the-f,--fail-fastflag:# will stop at 3.7 if it's not availablepdmmultirun-fi3.7,3.8pytesttests/If the command you run fails on a Python version, PDM Multirun stops there.
In any case, PDM Multirun will restore the Python interpreter
saved in.pdm-python(through thepdm usecommand) before exiting.
Package: pdm-mypyc
pdm-mypycpdm-mypycis a build hook forpdm-backendto compile source files withmypyc.Activate the hookTo enable the hook, simply add it to thebuild-system.requires:[build-system]requires=["pdm-mypyc","pdm-backend"]build-backend="pdm.backend"Besides, you can also disable it temporarily by setting environment variablePDM_BUILD_WITHOUT_MYPYCto1.ConfigurationInclude and exclude filesBy default, all.pyfiles included by thetool.pdm.buildconfiguration will be compiled with mypyc. You can override
it with theincludesandexcludessettings undertool.pdm.build.hooks.mypyctable:[tool.pdm.build.hooks.mypyc]includes=["src/**/*.py"]excludes=["src/**/tests/*.py"]# these files will be excluded **in addition to** the excluded files in the build configMypy argumentsYou can supply supportedmypy command line optionsto themypycifyfunction withmypy-argssetting:[tool.pdm.build.hooks.mypyc]mypy-args=["--disallow-untyped-defs","--disallow-any-generics"]OptionsYou can specify options to pass to themypycifyfunction.[tool.pdm.build.hooks.mypyc.options]opt_level="3"
Package: pdmn
pDMNWelcome to the pDMN solver's code repository.pDMN stands for Probabilistic Decision and Model Notation.
It is an extension to theDMNstandard, which aims to add probabilistic reasoning while maintaining DMN's goal of being readable and user-friendly.Installation and usageIn short for Linux: after cloning this repo, install the Python dependencies.git clone https://gitlab.com/EAVISE/cdmn/pdmn
cd pdmn
pip3 install -r requirements.txtAfter this, you can run the solver. Example usage is as follows:python3 -O solver.py Name_Of_XLSX.xlsx -n "Name_Of_Sheet" -o output_name.lpHow to referenceIf you wish to refer to pDMN or you use it in other works, please reference us as follows:Vandevelde, S., Verreet, V., De Raedt, L., & Vennekens, J. (2021). A Table-Based Representation for Probabilistic Logic: Preliminary Results. arXiv preprint arXiv:2110.01909.or@article{pDMN,
  title={A Table-Based Representation for Probabilistic Logic: Preliminary Results},
  author={Vandevelde, Simon and Verreet, Victor and De Raedt, Luc and Vennekens, Joost},
  journal={arXiv preprint arXiv:2110.01909},
  year={2021}
}
Package: pdm-packer
pdm-packerA PDM plugin that packs your packages into a zipappRequirementspdm-packer requires Python >=3.7InstallationOn PDM 1.6.4+, you can install the plugin directly by:$pdmpluginaddpdm-packerIf you have installed PDM with the recommended toolpipx, add this plugin by:$pipxinjectpdmpdm-packerOr if you have installed PDM withpip install --user pdm, install withpipto the user site:$python-mpipinstall--userpdm-packerOtherwise, installpdm-packerto the same place where PDM is located.Usage$ pdm pack [common-options] [pack-options]Common Options:-h, --helpshow this help message and exit-v, --verbose-v for detailed output and -vv for more detailed-g, --globalUse the global project, supply the project
root with-poption-p PROJECT_PATH, --project PROJECT_PATHSpecify another path as the project root,
which changes the base of pyproject.toml and__pypackages__Pack Options:-m MAIN, --main MAINSpecify the console script entry point for
the zipapp-o OUTPUT, --output OUTPUTSpecify the output filename. By default the file name
will be inferred from the project name.-c, --compressCompress files with the deflate method, no
compress by default--pyc, --compileCompile source into pyc files--no-pyRemove the .py files in favor of .pyc files-i INTERPRETER, --interpreter INTERPRETERThe Python interpreter path, default: the
project interpreter--exeCreate an executable file. If the output file
isn't given, the file name will end with
.exe(Windows) or no suffix(Posix)See also:https://docs.python.org/3.9/library/zipapp.htmlExamples# Create with default name(<project_name>.pyz) and console_script as the __main__.pypdmpack# Create an executable filepdmpack--exe# Create with custom __main__.py and filenamepdmpack-oapp.pyz-mapp:mainCaveatsIf the result zipapp contains binaries, it can only be deployed to the platforms with the same abi, any cross-abi usage of that app might expect a failure.Any console scripts except for what is given to--mainwill be lost.The .exe file is different from what is produced bypyinstallerin the way that it doesn't embed a Python interpreter. This means you have to install a Python with exactly the same version on the deployment platform.If you have code to run in your project, the project itself should be installed into__pypackages__as well. Make sure you have set a project name inpyproject.toml.About executable zipappBy default, zipapp is created with.pyzsuffix. On Windows, if you have associted.pyzfiles with Python program, you can run the app by double-clicking the file in the explorer. But if you create the app with--exeturn on, you can have a .exe file on Windows and anexecutablefile
on Unix-like systems, so that the app can be executed without apythoncommand prefixing it and
no matter you assoicated the file exensition properly or not.ChangelogSeeCHANGELOG.md
Package: pdm-pip-index-url
pdm-pip-index-urlpdm-pip-index-urlis a pdm plugin that automatically convertsPIP_*INDEX_URLtoPDM_PYPI_*envs.For each pdm sub-command invocation, pdm will search forPIP_*INDEX_URLenvironment variables to convert them to coresspondingPDM_PYPI_*values (seeprocess_pip_envsin./plugin.pyfor detailed logic description).UsageInstall plugin:pdm self add pdm-pip-index-urlpdm-pip-index-urlis compatbile withpython3.7+.LoggingTurn on logging by adding-vto executed command, e.g.:pdm add -v black.
Package: pdm-plugin-torch
🔦 pdm-plugin-torchA utility tool for selecting torch backend and version.What it doesDue to torch being published in many different variants with local versions to signify the underlying API, it is hard to integrate into a lockfile-based workflow. This is due to the local versions -+cu111,+cpu, and so on - being considered the "same" package, so you can't resolve two at the same time.This tool generate multiple lockfilesonly for torchand allows you to use a pdm subcommand (pdm torch) to select the one you want.ConfigurationThese are the supported options:[tool.pdm.plugin.torch]dependencies=["torch==1.10.2"]lockfile="torch.lock"enable-cpu=trueenable-rocm=truerocm-versions=["4.2"]enable-cuda=truecuda-versions=["cu111","cu113"]InstallationPDM supports specifying plugin-dependencies in your pyproject.toml, which is the suggested installation method. Note that inpdm-plugin-torchversions before 23.4.0, our configuration was intool.pdm.plugins.torch. If upgrading, you'll need to also change that totool.pdm.plugin.torch.[tool.pdm]plugins=["pdm-plugin-torch==$VERSION"]ContributionWe welcome community contributions to this project.Please read ourContributor Guidefor more information on how to get started.
Please also read ourContributor Termsbefore you make any contributions.Any contribution intentionally submitted for inclusion in an Embark Studios project, shall comply with the Rust standard licensing model (MIT OR Apache 2.0) and therefore be dual licensed as described below, without any additional terms or conditions:LicenseThis contribution is dual licensed under EITHER OFApache License, Version 2.0, (LICENSE-APACHEorhttp://www.apache.org/licenses/LICENSE-2.0)MIT license (LICENSE-MITorhttp://opensource.org/licenses/MIT)at your option.For clarity, "your" refers to Embark or any other licensee/user of the contribution.
Package: pdm-polylith-bricks
PDM Build Hook for PolylithA plugin forPDMand the Polylith Architecture.This build hook will look for Polylithbricksinpyproject.tomlandoptionallyre-write the imports made in the source code.Installation[build-system]requires=["pdm-backend","pdm-polylith-bricks"]build-backend="pdm.backend"The main usage of the build hook is to identify the included Polylith bricks from thepyproject.toml,
and hand them over to the PDM build process. Bricks are added to a project with relative paths,
from thebasesandcomponentsfolders in a Polylith Workspace.
The hook will copy the bricks into the temporary.pdm-buildfolder that is created by thepdm buildcommand.
This will make the builtwheelandsdistinclude proper paths to the source code.Polylith Bricks are defined in thetool.polylith.brickssection of thepyproject.toml:[tool.polylith.bricks]"../../bases/my_namespace/my_base"="my_namespace/my_base""../../components/my_namespace/my_component"="my_namespace/my_componentPolylith documentationthe Python tools for the Polylith ArchitectureThe build hook also add support for building Python libraries by re-writing source code with a custom top namespace.Why re-write code?Building libraries is supported inthe Python tools for the Polylith Architecture,
but you will need to consider that code will share the same top namespace with any other library built from the same monorepo.This can be a problem when more than one of your libraries are installed into the same virtual environment.
Python libraries by default are installed in a "flat" folder structure, two libraries with the same top namespace will collide.A Solution: add a custom top namespace during packaging of the library with PDM and this build hook.How is this done?The code in this repo usesAST(Abstract Syntax Tree) parsing to modify source code.
The Python built-inastmodule is used to parse and un-parse Python code.What's the output from this plugin?Without any custom namespace in the configuration: no changes in the code. Building and packaging as-is.With a Top Namespace configuration[tool.polylith.build]top-namespace="my_custom_namespace"my_custom_namespace/my_namespace//my_package__init__.pymy_module.pyBefore:frommy_namespace.my_packageimportmy_functionAfter:frommy_custom_namespace.my_namespace.my_packageimportmy_functionPolylith Documentationthe Python tools for the Polylith Architecture
Package: pdm-polylith-workspace
PDM Build Hook for a Polylith workspaceA plugin forPDMand the Polylith Architecture.This build hook is making the virtual environment aware of a Polylith Workspace.When runningpdm installit will add an additional pth file to the virtual environment,
including paths to thebasesandcomponentsfolders.UsagePDM has already a configuration option calledproject-dir, that is meant for defining a custom
path to the Python source code. But it only allows one directory.The code in a Polylith workspace is organized into two folders (bases, components),
and that is the reason for using this hook.Installation[build-system]requires=["pdm-backend","pdm-polylith-workspace"]build-backend="pdm.backend"This is only needed in the Polylith workspacepyproject.toml, and not in the individual projects.Polylith documentationthe Python tools for the Polylith Architecture
Package: pdm-publish
PDM PublishA PDM plugin to publish to PyPINOTE: Consider if you need this over usingtwinedirectlyInstallationIf you installedpdmviapipx:pipxinjectpdmpdm-publishorbrew:$(brew--prefixpdm)/libexec/bin/python-mpipinstallpdm-publishorpip:pipinstall--userpdm-publishUsagepdm-publishenablespdmto publish packages to PyPI by wrappingtwineinternally.
For example, to build and publish:# Using token authpdmpublish--passwordtoken# To test PyPI using basic authpdmpublish-rtestpypi-uusername-Ppassword# To custom indexpdmpublish-rhttps://custom.index.com/Full usage:$pdmpublish--help
Uploadartifactstoaremoterepository

Usage:

Options:-h,--helpshowthishelpmessageandexit-v,--verbose-vfordetailedoutputand-vvformoredetailed-g,--globalUsetheglobalproject,supplytheprojectrootwith`-p`option-pPROJECT_PATH,--projectPROJECT_PATHSpecifyanotherpathastheprojectroot,whichchangesthebaseofpyproject.tomland__pypackages__-rREPOSITORY,--repositoryREPOSITORYTherepositorynameorurltopublishthepackageto[envvar:PDM_PUBLISH_REPO]-uUSERNAME,--usernameUSERNAMETheusernametoaccesstherepository[envvar:PDM_PUBLISH_USERNAME]-PPASSWORD,--passwordPASSWORDThepasswordtoaccesstherepository[envvar:PDM_PUBLISH_PASSWORD]--dry-runPerformallactionsexceptuploadthepackage--no-buildDon'tbuildthepackagebeforepublishingConfigurationConfig ItemDescriptionDefault ValueAvailable in ProjectEnv varpublish.repoPyPI repo name (pypi/testpypi) or urlpypiTruePDM_PUBLISH_REPOpublish.usernamePyPI username__token__TruePDM_PUBLISH_USERNAMEpublish.passwordPyPI passwordTruePDM_PUBLISH_PASSWORDLinksChangelogContributing
Package: pdmreader
PDM readerInteractive reader forPowerDesignerPDM files.Features:View/search tablesVew table definitionGenerate DDL for various databases (currently MySQL and Oracle supported)Generate Java entity definitionSupport command historyRequirementPython 3.7+This tool only makes use of Python standard libraries.Installation# root or administrator permission may be requiredpipinstallpdmreaderIf you want to try some unreleased features, or customize the tool yourself, clone the repository and install it in development mode:gitclonehttps://github.com/bianjp/pdmreader.gitcdpdmreader# root or administrator permission may be requiredpythonsetup.pydevelopmentUsagepdmreaderPATH_TO_PDM_FILEThis will start an interactive "shell" which you can type commands.Typehelpto show available commands.Currently supported commands:COMMAND                       DESCRIPTION
--------------------------------------------------------------------------------
help                          Print help
t                             Toggle horizontal/vertical output. Default horizontal
tables                        Show tables
tables PATTERN                Show tables matching the given shell-style glob
seq                           Show sequences
seq PATTERN                   Show sequences matching the given shell-style glob
table TABLE                   Show definitions of the given table
mysql TABLE                   Generate MySQL DDL for creating the given table
oracle TABLE                  Generate Oracle DDL for creating the given table
java TABLE                    Generate Java entity definition for the given table
exit, Ctrl + D                ExitLicenseThis project is licensed under the terms of the MIT license.
Package: pdm-readiness
pdm-readinessApdmplugin to check if your project dependencies support specific Python version.[!NOTE]Many packages may still work just fine even when they are not listed as supported.
This plugin only checks the metadata provided by the package authors, so it is not
a guarantee that the package will work or not.SynopsisThe readiness report is divided into 4 sections:Supported dependencies- currently locked dependencies that support the target Python version.Update required- currently locked dependencies that do not support the target Python version, but have newer versions that do.Unsupported- dependencies: the most recent version of the dependency does not support the target Python version.Missing metadata- the package does not provide metadata about the supported Python versions.Plugins usesPyPI JSON APIto get the metadata.
It looks at classifiers likeProgramming Language :: Python :: 3.12to determine which versions are supported.Installationpdmselfaddpdm-readinessUsageRunpdm readiness <python_version>in the root of your pdm project.Example output:
Package: pdm-rename
pdm-renameThis plugin allows to dynamically rename folders during the build stage.Installationpdmselfaddpdm-renameUse itSpecifyrenamedictionary in[tool.pdm]section.[tool.pdm]rename={"a/b"="c/d"}If you want the folder to be included in your build, don't forget to specifybuild.includes.[tool.pdm.build]includes=["c"]
Package: pdm-scriptcomplete
PDM Script CompleteThisPDMplugin enables tab completion for pdm scripts.InstallationPDMPDM needs to be installed prior to installing the plugin. Please follow the instructions from the officialPDM README.The pluginYou can install the plugin withPDM:pdm self add pdm-scriptcompleteAs a local-only plugin:# pyproject.toml[tool.pdm]plugins=["pdm-scriptcomplete"]pdm install --pluginsUsagepdm script <ENTER>
Package: pd-multiprocessing
pd_multiprocessingpd_multiprocessing provides a simple, parallelized function to apply a user defined function rowwise on a Pandas Dataframe.Requirementspandas0.22.0+pytest3.4.1+DocumentationIf you want to build the documentation, you need the following packages:Sphinxsphinx_rtd_themem2rInstallationYou can easily install pd_multiprocessing viapipinstallpd-multiprocessingUsageA typical usage looks like thisimportpandasaspdfrompd_multiprocessing.mapimportdf_mapdeftwotimes(row):row['col2']=row['col1']*2returnrowif__name__=='__main__':df=pd.DataFrame.from_dict({'col1':range(100)})print(df_map(twotimes,df))
Package: pdm-utils
READMEPurpose:The pdm_utils repository provides the source code for pdm_utils Python package, developed in the SEA-PHAGES program to create, update, and maintain MySQL phage genomics databases.The source code is available on GitHub athttps://github.com/SEA-PHAGES/pdm_utils/.The user guide for the package is available on ReadTheDocs athttps://pdm-utils.readthedocs.io/en/latest/.The pdm_utils Python package is available on PyPI athttps://pypi.org/project/pdm-utils/.Contribution guidelines:Please contact us if you have any contributions or suggestions. Details about how to contribute can be found on the user guide.Developers:Travis Mavrich (trm53@pitt.edu) and Christian Gauthier (christian.gauthier@pitt.edu).
Package: pdm-vscode
PDM-VSCodeA PDM plugin that autogenerates workspace vscode settings for youInstallationInstall the plugin with PDM CLI:pdmpluginaddpdm-vscodeOr usingpipx inject:pipxinjectpdmpdm-vscodeUsageNo configuration is required,.vscode/settings.jsonwill be autogenerated afterpdm initand every execution ofpdm use.
Package: pdm-wheel
pdm-wheelA PDM plugin that save your requirements as wheels, similar topip wheelUse casesYou want to build wheels for your dependencies, but don't want to usepdm exportandpip wheel.You need to pass the wheels to a CI/CD pipeline, and don't want to build them on the CI/CD server.You want to install dependencies in a Docker image, but don't wan't to configure private repositories in the image.Supported versionsPython 3.10+PDM 2.7.4+InstallationInstall itjust like any other PDM plugin:pdmselfaddpdm-wheelIf you have installed PDM with the recommended toolpipx, add this plugin by:pipxinjectpdmpdm-wheelOr if you have installed PDM withpip install --user pdm, install withpipto the user site:python-mpipinstall--userpdm-wheelOptionally, you can also specifythe plugin in your projectpyproject.toml, to make it installable withpdm install --plugins:[tool.pdm]plugins=["pdm-wheel"]Usagepdmwheel[common-options][dependencies-selection-options][wheel-options]💡 Check the options for your version ofpdm wheelwith:pdmwheel--helpWheel Options:-w OUTPUT, --wheel-dir OUTPUTSpecify the output directory. It will be created it it does not exists. Default is the current directory./wheelsEnvironment variable:PDM_WHEEL_DIR--cleanClean the target directory before building.--no-cleanDo not clean the target directory before building. This is the default behavior.Notes on lockfilesPDM 2.8+ now saves the lockfiles with only hashes and no URL by default.There is currently a performance overhead, as some internals expect the URL to be present, else they will try to reach the indexes to get it.Thus, I recommend you usepdm lock --static-urlsto have fasterpdm wheeloperations.Read more about this inPDM's documentation.Examples# Save all dependencies (including dev deps) as wheels in the ./wheels folderpdmwheel-wwheels# Save all dev dependencies  as wheels in the ./wheels folderpdmwheel-wwheels--dev# Save all non-dev dependencies as wheels in the ./wheels folderpdmwheel-wwheels--prodCaveatspdm-wheeldoes not check whether the wheels are already built.ChangelogSeeGithub ReleasesAcknowledgementspdm-wheelis inspired bypip wheel.pdm-wheel's structure is based on frostming'spdm-packer
Package: pdm-winpacker
pdm-winpackerA PDM plugin to bundle python application with python and create a installer using NSIS.ConfigurationConfig itemDescriptionDefault valueRequiredwin-packer.app_nameApplication nameYeswin-packer.publisherApplication publisherNowin-packer.iconApplication iconNowin-packer.py_versionPython version for bundleYeswin-packer.py_bitPython bit for bundle64Nowin-packer.local_wheelslocal list of wheel to add to bundle[]Nowin-packer.commands.{command_name}.entry_pointEntry point for commandYeswin-packer.commands.{command_name}.consoleIf command is run in consoleFalseNowin-packer.commands.{command_name}.envDictionary of environment variables{}Nowin-packer.shortcuts.{shortcut_name}.targetShortcut targetYeswin-packer.shortcuts.{shortcut_name}.parametersParameters for shortcutNowin-packer.shortcuts.{shortcut_name}.iconIcon for shortcutNoAll configuration items use prefixpdm.tool, this is a viable configuration:Example configuration[tool.pdm.win-packer]app_name="Project"publisher="Project Lead"py_version="3.10.10"py_bit="64"local_wheels=["wheels/Flask_APScheduler-1.12.4-py3-none-any.whl"][tool.pdm.win-packer.commands.project]entry_point="project:cli"console=trueenv={PROJECT_ENV="packaged"}[tool.pdm.win-packer.shortcuts."Project Kiosk"]target="http://localhost:9797/kiosk"parameters="kiosk"icon="project.ico"[tool.pdm.win-packer.shortcuts."Project Manage"]target="http://localhost:9797/manage"UsageNote - nsismake is required to be installed.pdm winpacker- Command bundles the application with python and compiles the NSIS installer.