Saravanan666/pypi-org huggingface dataset:
Package: version-parser
Version ParserJavaScript Versionhttps://www.npmjs.com/package/version-parserPython VersionThe version parser is able to parse versions and figure out which of them are build in
one of the following three formats: Major-Version, Minor-Version and Build-Version.Possible input types are:VersionTypv1.2.3VersionV1.2.3Versionv_1_2_3FILENAMEv1_2_3FILENAMEV_1_2_3FILENAMEV1_2_3FILENAME1_2_3FILENAMEVM1m2b3CLASSNAME_BUILDVM1m2p3CLASSNAME_PATCHvM1m2b3CLASSNAME_BUILDvM1m2p3CLASSNAME_PATCH1.2.3STRIPPED_VERSION2312NUMBERInstallpipinstallversion-parserUsageCreate object with the version as a String as initial parameter.fromversion_parserimportVersionv1=Version("v2.3.4")To compare two version objects/numbers, simply put the versions as Strings into
seperate objects and compare them using the logical operators.fromversion_parser.versionimportVersionv1=Version("v2.3.4")v2=Version("v2.3.2")print(v1<v2)>>Falseprint(v1>v2)>>Trueprint(v1==v2)>>FalseThe last digets behind the last dot should be the Patch or Build Version Number.
Differences in this area should be compatible to each other.fromversion_parser.versionimportVersionv1=Version("v2.3.4")v2=Version("v2.3.5")print(v1==v2)>>Falseprint(v1.compatible_version_with(v2))>>TrueYou can also get only the Major, Minor or Build Version by using:fromversion_parserimportVersionv=Version("v2.3.4")v.get_major_version()2v.get_minor_version()3v.get_build_version()4It's possible to convert the version format, too:fromversion_parserimportVersion,VersionTypev=Version("v2.3.4")# VersionType = Versionprint(v.get_type())>>VersionType.Versionprint(v.get_typed_version(VersionType.FILENAME))>>v_2_3_4Any version can be represented by an Integer.The sections of major, minor, build/patched version should have a maximum of three digets.fromversion_parserimportVersionv=Version("v2.3.4")print(v.get_number())>>2003004VersionTypesVersionType.FILENAME"v_<MAJOR>_<MINOR>_<BUILD/PATCH>"VersionType.CLASSNAME"VM<MAJOR>m<MINOR>b<BUILD/PATCH>"VersionType.VERSION"v<MAJOR>.<MINOR>.<BUILD/PATCH>"VersionType.STRIPPED_VERSION"<MAJOR>.<MINOR>.<BUILD/PATCH>"VersionType.NUMBEReach section is filled zeros up to three digets"<MAJOR><MINOR><BUILD/PATCH>"VersionType.CLASSNAME_BUILDsame like CLASSNAME_BUILDVersionType.CLASSNAME_PATCH"VM<MAJOR>m<MINOR>p<BUILD/PATCH>"^PATCH
Package: version_probe
======================python version probe======================A tool for detecting the Python major version for a body of sourcecode.Quickstart==========```from version_probe import detect_version# Find the version used in sources files under ~/projects/ipv7v = detect_version("~/projects/ipv7")# something so advanced is, of course, written in Python 3assert v == 3v = detect_version("/opt/old_project")assert v == 2try:detect_version("~/projects/experimental")except ValueError as e:print("Syntax error detected in the experimental project: {}".format(e))```
Package: versionpy
VersionPySmall utility to version and release your python tools. Doesn't need any configuration files.Installconda install -c vladsaveliev versionpyUsageSet version to0.1.2, create a git tag and push:$ bump 0.1.2Increment bugfix (patch) component (e.g.0.1.2->0.1.3), create a git tag and push:$ bumpIncrement minor component (e.g.0.1.3->0.2), create a git tag and push:$ bump minorAllowed first arguments:major,minor,bugfix/patch, or exact version in format of 2 or 3-component version
with a possible pre-prerelease component:- 1.0.0
- 2.1
- 2.0pre
- 2.0.2a1For a tracked tool, you can check current version with a single command:$ version
0.2Under the hoodVersionPy tracks the version number in the fileyour_package/_version.py.When you run it for the first time, VersionPy would try to locate_version.py, orVERSION.txt, and if needed initialize_version.pyit in the main package.If you have several packages in the project and want to store_version.pyin a particular one, use-p:bump 0.0.1 -p your_packageIf the version argument is ommited, will set the version to0.0.
Package: versions
versionsParsing, inspecting and specifying versions.InstallingPython 3.8 or above is required.pipInstalling the library withpipis quite simple:$pipinstallversionsAlternatively, the library can be installed from source:$gitclonehttps://github.com/nekitdev/versions.git$cdversions$python-mpipinstall.poetryYou can addversionsas a dependency with the following command:$poetryaddversionsOr by directly specifying it in the configuration like so:[tool.poetry.dependencies]versions="^2.1.2"Alternatively, you can add it directly from the source:[tool.poetry.dependencies.versions]git="https://github.com/nekitdev/versions.git"ExamplesVersionsparse_versionis used to parse versions:fromversionsimportparse_versionversion=parse_version("1.0.0-dev.1+build.1")print(version)# 1.0.0-dev.1+build.1SegmentsAll version segments can be fetched with their respective names:>>>print(version.release)1.0.0>>>version.release.parts(1,0,0)>>>print(version.dev)dev.1>>>(version.dev.phase,version.dev.value)("dev",1)>>>print(version.local)build.1>>>version.local.parts("build",1)ComparisonVersions support total ordering:>>>v1=parse_version("1.0.0")>>>v2=parse_version("2.0.0")>>>v1==v2False>>>v1!=v2True>>>v1>=v2False>>>v1<=v2True>>>v1>v2False>>>v1<v2TrueSpecificationversionsalso supports specifying version requirements and matching version against them.Since versions support total ordering, they can be checked usingversion sets(viaparse_version_set):>>>fromversionsimportparse_version,parse_version_set>>>version_set=parse_version_set("^1.0.0")>>>version_set<VersionRange(>=1.0.0,<2.0.0)>>>>version=parse_version("1.3.0")>>>version.matches(version_set)True>>>another=parse_version("2.2.0")>>>another.matches(version_set)FalseAlternatively, one can usespecifiers, which are similar to version sets, except they retain
the structure of specifications given (viaparse_specifier):>>>fromversionsimportparse_specifier,parse_version>>>specifier=parse_specifier("^1.0.0")>>>specifier<SpecifierOne(^1.0.0)>>>>version=parse_version("1.3.0")>>>version.matches(specifier)True>>>another=parse_version("2.2.0")>>>another.matches(specifier)FalseVersionedversionsallows users to access versions of items that have the__version__attribute:>>>fromversionsimportget_version>>>importversions>>>get_version(versions)<Version(2.1.2)>DocumentationYou can find the documentationhere.SupportIf you need support with the library, you can send anemailor refer to the officialDiscord server.ChangelogYou can find the changeloghere.Security PolicyYou can find the Security Policy ofversionshere.ContributingIf you are interested in contributing toversions, make sure to take a look at theContributing Guide, as well as theCode of Conduct.Licenseversionsis licensed under the MIT License terms. SeeLicensefor details.
Package: versions-client
Adds a Prometheus exporter to your web application to read out version information.Installationpipinstallversions-client# This stores the OS packages upfront because it's very resource intensiveos-package-versions>/var/local/os-package-versions.yamlUsage>>>importversions_client>>>versions_client.generate_versions(version='1.0',revision='d0935f4')# HELP version_application version info.# TYPE version_application gaugeversion_application{version="1.0",revision="d0935f4"}1# HELP version_platform version info.# TYPE version_platform gaugeversion_platform{achitecture="64bit",name="linux",system="4.13.3-coreos",distro_version="8.9",distro_id="debian",distro_name="debian",type="x86_64"}1# HELP version_python version info.# TYPE version_python gaugeversion_python{date="2017-10-10 02:49:49",implementation="cpython",version="2.7.14",compiler="gcc 4.9.2"}1# HELP version_package version info.# TYPE version_package gaugeversion_package{version="4.9.2",group="os",name="libgcc1"}1version_package{version="4.9.2",group="os",name="libitm1"}1version_package{version="2.0.21",group="os",name="libevent-2.0-5"}1...version_package{version="0.30.0",group="python",name="wheel"}1version_package{version="15.1.0",group="python",name="virtualenv"}1version_package{version="1.0.0",group="python",name="versions-client"}1version_package{version="36.5.0",group="python",name="setuptools"}1version_package{version="3.12",group="python",name="pyyaml"}1version_package{version="0.0.21",group="python",name="prometheus-client"}1version_package{version="9.0.1",group="python",name="pip"}1version_package{version="0.2.0",group="python",name="envparse"}1...SettingsEnvironment variableDescriptionVERSIONS_OS_PACKAGE_PATHThe path to the stored os packages file.Usage with DjangoAdd application labels to your django settings:INSTALLED_APPS=(# ...'versions_client',# ...)...VERSIONS_AUTH=[('admin','secret')]VERSIONS_LABELS={'version':'v1.0','revision':'d0935f4',}a. Add the included URL’s:# urls.pyfromdjango.conf.urlsimportinclude,urlurlpatterns=[url(r'^',include('versions_client.django.urls')),]This creates an endpoint on/versionz.b. Or create your own URL’s and views:# urls.pyfromdjango.conf.urlsimportinclude,urlfrom.importviewsurlpatterns=[url(r'^metrics$',views.metrics_view,name='prometheus-django-metrics'),]To get more metrics, you could integratedjango-prometheus.In this example we combine our metrics with those fromprometheus-client.# views.pyimportprometheus_clientfromdjango.confimportsettingsfromdjango.http.responseimportHttpResponseimportversions_client@versions_client.django.auth.basicdefmetrics_view(request):application_labels=getattr(settings,'VERSIONS_LABELS',{})metrics_page=prometheus_client.generate_latest()version_page=versions_client.generate_versions(**application_labels)returnHttpResponse(metrics_page+version_page,content_type=prometheus_client.CONTENT_TYPE_LATEST)
Package: versiontag
Python project versioning for lazy peopleWhat’s versiontag?Versiontag is an ultra-simple library design to make accessing the current
version number of your software easy.Why do I need it?Version numbers are all too often duplicated among setup.py, git tags, and
other sources of truth. This library makes it possible to consolidate on git
tags as a single source of truth regarding version numbers. That decreases the
likely hood of making errors when publishing new package versions.Full Documentation:https://python-versiontag.readthedocs.io
Package: version-test-v2
Getting startedSimple calculator API hosted on APIMATICHow to BuildYou must have Python2 >=2.7.9or Python3 >=3.4installed on your system to install and run this SDK. This SDK package depends on other Python packages like nose, jsonpickle etc.
These dependencies are defined in therequirements.txtfile that comes with the SDK.
To resolve these dependencies, you can use the PIP Dependency manager. Install it by following steps athttps://pip.pypa.io/en/stable/installing/.Python and PIP executables should be defined in your PATH. Open command prompt and typepip --version.
This should display the version of the PIP Dependency Manager installed if your installation was successful and the paths are properly defined.Using command line, navigate to the directory containing the generated files (includingrequirements.txt) for the SDK.Run the commandpip install -r requirements.txt. This should install all the required dependencies.How to UseThe following section explains how to use the VersionTestV2 SDK package in a new project.1. Open Project in an IDEOpen up a Python IDE like PyCharm. The basic workflow presented here is also applicable if you prefer using a different editor or IDE.Click onOpenin PyCharm to browse to your generated SDK directory and then clickOK.The project files will be displayed in the side bar as follows:2. Add a new Test ProjectCreate a new directory by right clicking on the solution name as shown below:Name the directory as "test"Add a python file to this project with the name "testsdk"Name it "testsdk"In your python file you will be required to import the generated python library using the following code linesfromversion_test_v_2.version_test_v_2_clientimportVersionTestV2ClientAfter this you can write code to instantiate an API client object, get a controller object and  make API calls. Sample code is given in the subsequent sections.3. Run the Test ProjectTo run the file within your test project, right click on your Python file inside your Test project and click onRunHow to TestYou can test the generated SDK and the server with automatically generated test
cases. unittest is used as the testing framework and nose is used as the test
runner. You can run the tests as follows:From terminal/cmd navigate to the root directory of the SDK.Invokepip install -r test-requirements.txtInvokenosetestsInitializationAPI client can be initialized as following.client=VersionTestV2Client()Class ReferenceList of ControllersSimpleCalculatorControllerSimpleCalculatorControllerGet controller instanceAn instance of theSimpleCalculatorControllerclass can be accessed from the API Client.simple_calculator_controller=client.simple_calculatorget_calculateCalculates the expression using the specified operation.defget_calculate(self,options=dict())ParametersParameterTagsDescriptionoperationRequiredThe operator to apply on the variablesxRequiredThe LHS valueyRequiredThe RHS valueExample Usagecollect={}operation=OperationTypeEnum.MULTIPLYcollect['operation']=operationx=4collect['x']=xy=5collect['y']=yresult=simple_calculator_controller.get_calculate(collect)Back to List of Controllers
Package: versiontracker
Version Trackeris a project
that provides both a command-line tool and a Python library to query the latest
stable versions of different software products using web scrapping.For example:$ versiontracker vlc
vlc: 2.2.2 (2016-07-06) @ http://get.videolan.org/vlc/RequirementsVersion Tracker requiresPython 3and the
following Python packages:python-dateutilpyxdgScrapytermcolorTo build the offline documentation, you also need:sphinx-argparseInstallationUsepipto install:pip install versiontrackerBasic Command-Line UsageTo use the versiontracker command-line application pass
it a list of software IDs:$ versiontracker vlc xfce
vlc: 2.2.2 (2016-07-06) @ http://get.videolan.org/vlc/
xfce: 4.12 (2015-02-28) @ http://archive.xfce.org/xfce/You can use the-loption to get a list of supported software IDs:$ versiontracker -l
0ad
4kslideshowmaker
…Basic Library UsageUseversion_info()to get information
about the latest stable version of a single product:>>> from pprint import pprint
>>> from versiontracker import version_info
>>> pprint(version_info('vlc'))
{'id': 'vlc',
 'date': datetime.datetime(2016, 7, 6, 10, 10),
 'url': 'http://get.videolan.org/vlc/',
 'version': '2.2.2'}Useiter_version_info()to iterate
through the version information of several products:>>> from versiontracker import iter_version_info
>>> for version_data in iter_version_info(('vlc', 'xfce')):
...     pprint(version_data)
...
{'id': 'vlc',
 'date': datetime.datetime(2016, 7, 6, 10, 10),
 'url': 'http://get.videolan.org/vlc/',
 'version': '2.2.2'}
{'id': 'xfce',
 'date': datetime.datetime(2015, 2, 28, 21, 7),
 'url': 'http://archive.xfce.org/xfce/',
 'version': '4.12'}Usesupported_software()to get a
list of supported software IDs:>>> from versiontracker import supported_software
>>> supported_software()
['kde-l10n-ca', 'kdiamond', 'kontactinterface', 'entropy', …]DocumentationSee the complete documentation atRead the Docs.
Package: versionup
versionup is an auto version tool with a command line utilitygo to any directory with a setup.py and call either
upversion or showversion
and it will do the rest.if you tell it not to set up your setup.py file
then add
from versionup import get_version
version = get_version()# then replace your
‘version’ : ‘x.x.x’, or ‘version = ‘x.x.x’,
# with
‘version’ : version  or ‘version’ = version,or just let it do it for you…to install
just
sudo python setup.py install
Package: version-updater
# (Semantic) Version UpdaterA simple tool for updating versions of both dependencies and main artifact versions in CI pipelines based on semantic versioning. The main use-cases are:Explicitly set a dependency version to the new one produced by a successful pipeline runBump the semantic version of the artifact produced by a repo’s build pipeline. This could happen at the same time as the previous use-caseTypically, a chain of CI pipelines need to trigger updates to dependent projects once an acceptable testing outcome has been achieved, and you still want team membebrs to be able to clone a repo that has been auto-managed in this way and have a complete, working dependency file without any variables. This tool is aimed at solving that issue.# InstallationTBD# Examples## Set some dependency versions to new ones from a prior CI pipeline, and bump the major version (package.json)update-version –set-dependencies react=1.2.3,react-dom=2.3.4 package1.json –bump major## Update the patch version in the .gitlab-ci.ymlupdate-version –bump patch .gitlab-ci.yml## Update a dependency and main version of setup.pyupdate-version –set-dependencies semver=4.5.6 setup.py –bump major## Update a dependency in requirements.txt; ignore bumping the main version which is meaninglessupdate-version –set-dependencies gtfs-realtime-bindings=4.5.6 foo-requirements.txt –bump major
Package: version-upper
version-upperPrimarily a reaction tobumpversionnot supporting git hashes --issueOverviewUsage: version-upper [OPTIONS] COMMAND [ARGS]...

  A tool to update version strings in files using semantic versioning and
  commit hashes.

  Examples:

  # bump commit hash version
  version-upper bump commit_hash

  # bump patch version
  version-upper bump patch

  # bump patch version as release candidate
  version-upper bump patch --release-candidate

  # bump minor version
  version-upper bump minor

  # bump major version
  version-upper bump major

  The config file adheres to the Config Pydantic schema, and is named
  version-upper.json by default.

  Here is a sample config:
  {
      "current_version": "0.0.0",
      "current_semantic_version": "0.0.0",
      "files": []
  }

Options:
  --config TEXT  [default: version-upper.json]
  --help         Show this message and exit.

Commands:
  bump                      Bumps version strings, updates config.
  config-schema             Prints the config schema in JSON
  current-semantic-version  Prints the current semantic version
  current-version           Prints the current version
  release                   Removes rc from the version strings
  sample-config             Prints a sample configConfigurationCreate a file calledversion-upper.json(can be overridden using--config) like below:{"current_version":"0.0.0","current_semantic_version":"0.0.0","files":["main.py","app/version.json"]}Be sure to add files to"files"otherwise nothing will be updated :)
Package: versionutil
Convenience function for comparing Python system versionInstallationFrom the project root directory:$ python setup.py installUsageProvides compare_python version so that you can check against the major, minor and micro version:from versionutil import compare_python, PYTHON

# compare_python will return a boolean value against the current system version.
# PYTHON represents an instance of an object that is the current system version.

# It will check at the most significant value you signify. Default is equality check.
# True using 2.7.9:
PYTHON == '2'
PYTHON == '2.7'
PYTHON == '2.7.9'
compare_python('2')
compare_python('2.7')
compare_python('2.7.9')

# True using 3.4.4:
PYTHON == '3'
PYTHON == '3.4'
PYTHON == '3.4.4'
compare_python('3')
compare_python('3.4')
compare_python('3.4.4')

# False in 3.4.4:
PYTHON != '3.5'
PYTHON != '3.4.5'
compare_python('3.5')
compare_python('3.4.5')

# Works with ints and even floats:
PYTHON == 2.7
compare_python(2.7)

# Different comparisons exist, default comp='=='
PYTHON != 3
PYTHON < 3
PYTHON < 3.0
PYTHON > 2.6
PYTHON >= 2.7
PYTHON < 3.1
compare_python(3, '!=')
compare_python(3, '<')
compare_python(3.0, '<')
compare_python(2.6, '>')
compare_python(2.7, '>=')
compare_python(3.1, comp='<')

# To test against a custom system version (ignore sys.version_info):
compare_python(5.4, sysv=(5, 4, 5))
# or to create a PYTHON like object for 5.4.5:
from versionutil import PythonVersion
pv545 = PythonVersion(sysv=(5, 4, 5))
if pv545 == 5.4: # True...

# Useful for handling imports, where otherwise pyfuture and pasteurize might not have what you need.
if PYTHON < 3:
    from oldapi import OldAPI as API
elif PYTHON == 3.0 or PYTHON == 3.1:
    from newapi import OtherAPI as API
elif PYTHON >= 3.2:
    from newapi import NewAPI as APIRelease Notes0.1.2:Check is_instance(str) for 3.4 and basestring for <0.1.1:Added PYTHON global and PythonVersion class for easier usage (PYTHON < 2.7)0.1.0:Alpha finished, tested fully with tox0.0.1:Project created
Package: version-wizard
The version wizard extracts version information from a git tag and includes it in your python package so you don’t have to worry about commit messages likeBump version to 0.8.1anymore. Here’s how to use the wizard:Install by runningpip install version-wizard.Addinclude VERSIONto yourMANIFEST.infile (or create one by runningecho "include VERSION" > MANIFEST.in).Update yoursetup.pyas shown below.Pushsemantic versioningtags to your GitHub branch, e.g,0.8.1.# setup.pyfromsetuptoolsimportsetup,...fromversion_wizardimportfrom_github_tagsetup(version=from_github_tag(),...)Behind the scenesThe call tofrom_github_tagwill do one of two things:If theVERSIONfile exists, it simply returns its contents. This is the typical behavior when your installing the package from pypi, for example.If theVERSIONfile doesnotexist, it will try to extract the version from theGITHUB_REFenvironment variable and write it to theVERSIONfile.Because theMANIFEST.inincludesVERSION, theVERSIONfile will be included in any distribution, e.g., when you runpython setup.py sdist. The correct version is thus automatically packaged with your distribution elminiating any possible inconsistencies.Interface..automodule:: version_wizard
  :members:
Package: versium-reach-sdk
Versium Reach API Software Development Kit (SDK)A simplified Python interface for appending data usingVersium Reach APIsInstallationIt's recommended that you first create a virtual Python environment before installing using tools such as virtualenv or
conda. This is to prevent you from installing the package directly onto your system's base Python installation. Once
you have created and activated your virtual environment, proceed with one of the steps below.PyPIpipinstallversium-reach-sdkInstall from SourceClone or download the codebase from theGitHub PageCD into the newly downloaded or cloned foldercdreach-path-python-sdkNow install the package with pippipinstall.UsageImport ReachClient into your programfromreachimportReachClientPass yourAPI Keyto the ReachClient constructor.client=ReachClient('api-key-012345678')Run theappendmethod of yourReachClientobject with the API name, input records, desired outputs (if applicable),
and any extra config parameters you wish to pass.records=[{"first":"John","last":"Smith","address":"123 Main St.","city":"New York","state":"NY"}]results=client.append(api_name="contact",input_records=records,outputs=["phone","email"],config_params={"match_type":"indiv"})Returned ResultsResults are returned as a list of QueryResult objects, which contain the following attributes:body:
The parsed body of the response from the Versium Reach API.success:
Indicates whether the request returned with a successful status code.match_found:
Indicates whether a match was found for the queried recordhttp_status:
The http status code for the response.reason:
Explanation of the http status code (e.g. 200 => "OK", 404 => "Not Found", 401 => "Unauthorized", etc.)headers:
The headers of the response.body_raw:
The body of the response as raw bytesrequest_error:
If the client errored out during a request, this stores the error objecterror_msg:
Stores additional info about query errors.Things to keep in mindThe default rate limit for Reach APIs is 20 queries per secondYou must have a provisioned API key for this function to work. If you are unsure where to find your API key,
look at ourAPI key documentation