Saravanan666/pypi-org huggingface dataset:
Package: argumentor
argumentorDescriptionA simple, copylefted, lightweight library to work with command-line arguments in PythonFeaturesNo external dependencyEasy to useAutomatic help page generationSupport for default valuesPublished under LGPLv3, a copyleft license that still lets you use the library in a project that is not under the same licenseInstallation$pipinstallargumentorUsagefromargumentorimportArgumentsparser=Arguments()parser.add_operation(operation="--help",value_type=bool,description="Print help page")operations,options=parser.parse()ifoperations["--help"]:print(parser.help_page)More usage can be foundin the documentationLicenseThis repository and its content (unless specified otherwise) are released under the terms of theGNU Lesser General Public License version 3.
Package: argumentsprocessor
A Python module that process a dictionary of arguments against a
supplied dictionary of expected arguments.Installpip install argumentsprocessorDocumentationArgumentsProcessor ModuleProcesses arguments according to a supplied dictionary containing expected arguments
and rules.

@includes:
    ArgumentsProcessor
    ArgumentsProcessorExceptions

@requires:
    'expected_arguments' = {   -- categories are synonymous to the arguments you pass
        'category_a' : { -- this is will be whatever you name your argument, see the example below
            'arguments: (
                'hello',
                'bye'
            ),
            'required' : True || False,
            'returns' : 'string' -- default is string but you may pass the string name of any
               python variable type or pass in a custom object
        },
        'category_b' : {
            arguments: (
                'data'
            ),
            'required' : True || False,
            'returns': 'string' -- default is string but you may pass the string name of any
               python variable type or pass in a custom object
        }
    }

@return:
    arguments = {
        'category_a':return_value, -- either the default string, any python type, or custom object passed in
        'category_b':return_value, -- either the default string, any python type, or custom object passed in
     }


@example:

import ArgumentsProcessor

class classy:

    expected_arguments = {
        'mode': {
            'arguments': (
                'encrypt',
                'decrypt'
            ),
            'required': True,
            'return': 'string'
        },
        'data': {
            'arguments': (
                'data'
            ),
            'required': True,
            'return': 'string'
        }
    }

    def __init__(self, mode, data):
        supplied_arguments = {
            'mode':mode,
            'data':data
        }
        arguments = ArgumentsProcessor(self.expected_arguments, s
Package: argument-tasks
ArgumentTasksThis library helps you to call easily defined tasks for your project, all you need to do is create afilefor your tasks and aymlwith their description.ExampleLet's say you want to create a task for your project that welcomes people to your app, in this case, 'ArgumentTasks lib'. To do that you need to importInterfaceclass from the library and instantiate it as follows:fromargument_tasksimportInterfacefromexample_dataimportmethodsSOURCE_YML_FILE=open("example_data/tasks.yml","r")Interface(SOURCE_YML_FILE,methods).run()As you can see, we have defined a folderexample_datathat contains aymlfile where the tasks are defined, and amethodsfile where the task's code is defined. Finally, the output for the code above is the text thehello_argmethod from the methods file is printing.Hello from ArgumentTasks lib!Now, the methods defined are normal functions that must contain the parameter**kwargs. Bellow is themethodsfile code imported in the example.defhello_arg(**kwargs):print("Hello from ArgumentTasks lib!")There's also a necessaryymlfile in the example calledtasks.ymlwhere the tasks are defined. Below is the file code used in the example.hello:
  action: hello_arg
  values: []As you can see the file has a certain structure, here is an example of it.<command_name: str>:
    action: <method_name: str>
    values:
        -
            name: <arg_name: str>
            type: <arg_type: python_class>
            required: <whether_arg_is_required: bool>
            description: <arg_description: str>Cheers 👍
Package: argunizer
DescriptionArgunizer is a tool for restructuring an unstructured directory hierarchy into a
temporal timeline of files in UTC, universal co-ordinated time. By an unstructured
directory hierarchy I mean the types of directories, which users normally create
on their desktops, which often encode meaning into the directory names.LogicThe timeline is contructed out of the last modification
times of all the files in the source directory. Each of the files is then either:symlinked under the destination directory (default)copied from source to destination directorymoved from source to destination directoryLayoutFiles or symlinks are rendered as:YYYY/MM/DD/<file>NoteOptionally, it will also be possible to clean up an empty shell of directories, which
has resulted from the move semantics.
Package: argunparse
Reversed argparse: generate string of command-line args from Python objects.Theargunparseis intended to perform an approximate reverse of whatargparsedoes. In short:
generating string (or a list of strings) of command-line arguments from a dict and/or a list.ContentsHow to useRequirementsInstallationLinksHow to useSimple example of howargunparseworks:importargunparseoptions={'v':True,'long-flag':True,'ignored':False,'also-ignored':None,'o':'out_file.txt','log':'log_file.txt'}args={'in_file.txt'}unparser=argunparse.ArgumentUnparser()print(unparser.unparse(*args,**options))# -v --long-flag -o=out_file.txt --log=log_file.txt in_file.txtprint(unparser.unparse_to_list(*args,**options))# ['-v', '--long-flag', '-o=out_file.txt', '--log=log_file.txt', 'in_file.txt']Special option values are:True– option will be treated as a flag;FalseandNone– option will be ignored.All other values will be converted to strings usingstr().For more examples seeexamples.ipynbnotebook.RequirementsPython version 3.8 or later.Python libraries as specified inrequirements.txt.Building and running tests additionally requires packages listed inrequirements_test.txt.Tested on Linux, macOS and Windows.InstallationFor simplest installation usepip:pip3installargunparseLinksargparse:https://docs.python.org/3/library/argparse.html
Package: argupdate
argupdateThis package is used for updating values in the args/kwargs destined to
a function. This is particularly useful for decorators that want to
modify the values passed into the decorated function.By introspecting the function the args/kwargs are destined for, it knows
the names of all arguments in your args (and of course your kwargs since
that is a dict). Because of this, you are able to provide updated values
by name of the argument.By accepting a special callable, we also provide a way to dynamically
update the value of an argument at runtime.simple exampleThe function we want to modify a value forfromtypingimportOptionaldeffoo(arg_1:int,arg_2:bool,arg_3:Optional[str]=None)->None:print(arg_1,arg_2,arg_3)Let's say for some reason we always wantarg_2to beFalse, no
matter what the caller passes in.importfunctoolsfromargupdateimportupdate_parameter_valuefromtypingimportOptionaldefarg_2_always_false(func):# This is the new value for `arg_2`updated_values={'arg_2':False}@functools.wraps(func)defwrapper(*args,**kwargs):# Here we update the value.updated_args,updated_kwargs=update_parameter_value(func,updated_values,args,kwargs)returnfunc(*updated_args,**updated_kwargs)returnwrapper@arg_2_always_falsedeffoo(arg_1:int,arg_2:bool,arg_3:Optional[str]=None)->None:print(arg_1,arg_2,arg_3)Admittedly, this is a contrived example. You could've just set set the
second parameter inargstoFalsewithout using this library. But,
even in this small, contrived example, you've gained some decoupling by
usingargupdate. As long as the name of the parameter stays the same,
you do not have to count on it being the second parameter in the
argument list.more advanced exampleYou can also use a special callable as the new value. This allows you to
set the new value based upon the signature of the function and other
argument's values.Here is an example taken from a real project. This project wrapped
multiple other backend libraries. These libraries all had methods that
took ahandleargument as anint. Except one. This one library
required thehandleargument as a string that looked like[HANDLE:0x0000001].Instead of repeating code everywhere checking which type of handle we
should pass in, we created a decorator that did it for us.importfunctoolsimportinspectfromtypingimportAny,Mapping,Sequencefromargupdateimportupdate_parameter_value,ValueUpdaterfromutilsimportstringify_intdefhandle_stringifier(func):classupdate_handle(ValueUpdater):def__call__(self,original_value:Any,signature:inspect.Signature,orig_args:Sequence[Any],orig_kwargs:Mapping[str,Any])->Any:ifisinstance(original_value,int):returnstringify_int(int)returnoriginal_valueupdated_values={# update_handle will be used to create the value for the argument# called `handle`'handle':update_handle}@functools.wraps(func)defwrapper(*args,**kwargs):updated_args,updated_kwargs=update_parameter_value(func,updated_values,args,kwargs)returnfunc(*updated_args,**updated_kwargs)returnwrapper@handle_stringifierdefweird_handle_taker(handle:int)->None:...
Package: argupy
argupyEasy-to-use argument manager for Python3.InstalationTo install argupy, runpip3installargupyUsageTo use it in a Python script, first you need to import it.fromargupyimport*Then, initialize theArgsclassargupy=Args()and define any parameters you'll want to use later on.argupy.setarg('--testarg',BOOL)You can optionally pass a list of parameters toArgs(), but if you don't, it defaults tosys.argv. The first item will be ignored.Thesetargfunction takes these parameters:name: the parameter name, for example, '--test'.type_: the parameter type, pass a constant likeBOOL,STR,INT, orFLOAT. Note the underscore to prevent conflicts with the built-intype()function.default_value:optional. The default value to return if the argument is not present. Defaults toFalseif the argument is of typeBOOL.short:optional. The short name for the argument, usually one letter. For example, long:--help, short:-h.To use short names, do it like this:argupy.setarg('--testarg',BOOL,short='-t')To define an argument which takes a value, use the typesSTR,INTorFLOAT. Then retreive it with theArgs.arg()method.argupy.setarg('--testarg',STR)value=argupy.arg('--testarg')print(type(value),value)# Running this code like this:# python3 file.py --testarg hello# would output: <class 'str'> helloIf the argument type is set toSTR, the returned value will be of typestr. And again, if the argument is of typeINTorFLOAT, the returned value will be of typeintorfloat, so you don't have to pass it throughint()orfloat(). Unless the argument is not present and the default value you specify is not of the corresponding type.
To passSTRvalues with spaces, put double-quotes around them, like this:python3file.py--testarg"Chicago, Los Angeles"Also, for debugging purposes, if you print an argument like thisprint(argupy.args['--testarg'])the output will be something like:Arg(name='--testarg',type_='boolean',default_value=False)orArg(name='--testarg',type_='boolean',default_value=False,link=True,target='--anotherarg')orArg(name='--testarg',type_='boolean',default_value=False,links=['--anotherarg'])
Package: argus
# Helper routines for using multiple, inexpensive camerasBrandon Jackson and Dennis Evangelista, 2014-2015Eventually setup cloneable Bitbucket repository:` hg--clonessh://hg@bitbucket.org/devangel77b/argus`To install the module, run (as administrator):` python setup.py install `This also works although it only gives last stable:` sudo pip install argus `## What’s new in Version 0.0.11Hopefully this brings PyPI in line with Bitbucket etc## What’s new in Version 0.0.10Seems to work for Python 3 and OpenCV 3CMei Omnidirectional Camera stuffUpdated README and documentationBug fixesnow available through [https://pypi.org/project/argus/]API documentation at [http://argus.readthedocs.io/en/latest/]## DescriptionArgus had 1000 eyes.  You might only have 3 cameras but hopefully this is
useful.This Python module includes helper routines for calibrating, synchronizing,
and using multiple inexpensive cameras for reconstructing 3D positions for
scientific uses, such as in biology, biomechanics, ecology, etc. This module
includes chessboard calibration, automatic wand tracking, and synchronization
using sound and is intended to interface with the python sba sparse bundle
adjustment routines for 3D calibration and reconstruction.Companion Matlab routines are also available.If these routines are helpful in your work, please cite Jackson, Evangelista, Ray, Hedrick (2016), 3D for the people: multi-camera motion capture in the field with consumer-grade cameras and open source software,Biology Open5:1334-1342:`bibtex @article{Jackson:2016:3D,author={Jackson,B and Evangelista, D and Ray, D and Hedrick, T},year={2016},title={3Dfor the people:multi-cameramotion capture in the field withconsumer-gradecameras and open source software},journal={BiologyOpen},volume={5},pages={1334--1342},doi={10.1242/bio.018713}}`## Still to doAutowand and keypoint finder for automatic detection of extrinsic calibration
points.  Also provide worked example with sparse bundle adjustment (sba is
part of the Python sba library / or is implemented in Matlab in EasyWand).## See alsoThe Argus GUI is here [https://kilmoretrout@bitbucket.org/kilmoretrout/argus_gui] or visit [http://argus.web.unc.edu] for Windows and MacOS builds.## Thanks toTy Hedrick, Dylan Ray, Talia Weiss, others
Package: argus-notification-msteams
ALPHA-VERSION!This is a plugin to send notifications to MSTeams fromArgusDifferent levels of incidents have hard-coded colors.Version 0.5.1 and older can be used by argus-server version 1.9.x to 1.13.x.Django settingsAddargus_notification_msteams.MSTeamsNotificationtoMEDIA_PLUGINS:MEDIA_PLUGINS = [
    ..
    "argus_notification_msteams.MSTeamsNotification",
]The plugin uses the settingNOTIFICATION_SUBJECT_PREFIX.ConfigurationCreate a webhook inside MS Teams, which results in a long url that needs to be
stored in thesettings-field.You can test without invoking the frontend by adding the webhook manually in
Django admin.POST-ing to the API:/api/v2/notificationprofiles/destinations/, POSTed body:{
  "media": "msteams",
  "label": "whatever",
  "settings": {
    "webhook": "https://msteams.domain/some-very-long-webhook-specific-path"
  }
}GET-ing from the API:/api/v2/notificationprofiles/destinations/{id}/, received result:{
  "pk": 0,
  "media": {
    "slug": "msteams",
    "name": "MS Teams"
  },
  "label": "whatever",
  "suggested_label": "whatever",
  "settings": {
    "webhook": "https://msteams.domain/some-very-long-webhook-specific-path"
  }
}
Package: arguspy
arguspy[Deprecated] As nagios is too old, this project is deprecated.Please Move to another project[super-devops].Arguspy is pure python code.It’s a API packge for monitoring plugins, like Nagios, Icinga, Naemon, Shinken, Centreon, Opsview and Sensu.[awesome-monitoring].How to installUse pip to install:$ pip install super_devops
$ pip install arguspyHow to useJust import what protocol you need:from arguspy.ftp_ftplib import Ftp
from arguspy.http_requests import Http
from arguspy.mssql_pymssql import Mssql
from arguspy.mysql_pymysql import Mysql
from arguspy.ssh_paramiko import Ssh
from arguspy.winrm_pywinrm import WinRM
from arguspy.wmi_sh import Wmi
from arguspy.wmi_subprocess import WmiThen write your own function monitoring class:class YourClass(Ftp/Mssql/Ssh/WinRM/Wmi/Http/Snmp/...):
    def __init__(self):
        super(YourClass, self).__init__()
        self.logger.debug("Init YourClass.")

    def define_sub_options(self):
        super(YourClass, self).define_sub_options()
        self.your_parser = self.subparsers.add_parser(...)
        self.your_parser.add_argument(...)
        ...

    def your_handle(self):
        """Put your function monitoring code here."""
        # Default status is ok.
        status = self.ok

        # Call the API and get the monitoring data.
        # Read the document or check the API on python/ipython Interactive console.
        # help(Ftp/...)
        # dir(Ftp/...)
        ...

        #  Compare with the warning and critical value and change the status.
        ...

        self.shortoutput = "..."
        self.longoutput.append(...)
        self.perfdata.append(...)

        self.logger.debug("Return status and output.")
        status(self.output())If you put more than one function monitoring class in one file(Not recommend):class Register(YourClass1, YourClass2, ...):
    def __init__(self):
        super(Register, self).__init__()Last step:def main():
    plugin = Register()
    if plugin.args.option == 'action':
        plugin.action_handle()
    elif ...:
        ...
    else:
        plugin.unknown("Unknown actions.")

if __name__ == "__main__":
    main()How to extendsCheck the TODO list, you can give test examples or documents.Also you can pull request for your code.TODOWrite unit tests in tests/Write docs in docs/Write examples in examples/Compatible with Python3vSphere monitoringLDAP monitoringSNMP monitoringContribution[Contribution]Authors[Authors]License[License]
Package: argus-temporal-logic
Argus: Temporal Logic Monitoring ToolArgus aims to be a tool to generate monitors for Signal Temporal Logic (STL), and its
different semantics.This library is a direct successor of mysignal-temporal-logictool,
and is inspired by the following projects:py-metric-temporal-logicis a tool written in pure Python, and provides an elegant
interface for evaluating discrete time signals using Metric Temporal Logic (MTL).RTAMTis a Python library for offline and online
monitoring of STL specifications.BreachandS-TaLiRoareMatlabtoolboxes designed for falsification and
simulation-based testing of cyber-physical systems with STL and MTL specifications,
respectively. One of their various features includes the ability to evaluate the
robustness of signals against STL/MTL specifications.The goal of this tool is to provide offline and online monitors for Signal Temporal
Logic (STL) and its semantics, focussing on performance and ease of use in controllers
(for training and monitoring them).The project name is inspired fromArgus Panoptes.
Package: argus-ticket-github
argus_ticket_githubThis is a plugin to create tickets in Github fromArgusSettingsTICKET_ENDPOINT:"https://github.com/"or link to self-hosted instance, absolute URLTICKET_AUTHENTICATION_SECRET: Create apersonal access tokenwith the scoperepo:{
    "token": token
}It is recommended to create a Github API user and to ensure that that user
has the necessary authorization for creating issues in the relevant
repository.TICKET_INFORMATION:Project namespace and name (obligatory){
    "project_namespace_and_name": project_namespace_and_name
}To know which project to create the ticket in the Github API needs to know
the owner and name of it. The owner is the user or organization the Github
repository belongs to and the name is the name of the Github project.For the Github projectHello Git Worldthe
dictionary would look like this:{
   "project_namespace_and_name": "githubtraining/hellogitworld",
}Labels (optional)There are two ways of automatically filling labels:Labels that are always the same, independent of the incident.
These will be set inlabels_set.{
    "labels_set" : [
        label1,
        label2,
        label3,
    ]
}Labels that are filled by attributes of the Argus incident.
These are set inlabels_mappingwhich is a list of the names of the
attributes as they are returned by the API (e.g.start_time). If the
information can be found in the tags the it has to be a dictionary withtagas the key and the name of the tag as the value (e.g.
{"tag": "host"}).{
    "labels_mapping" : [
        attribute_of_incident,
        {"tag": name_of_tag},
    ]
}Code styleargus_ticket_github uses black as a source code formatter. Black can be installed
by running$pipinstallblackA pre-commit hook will format new code automatically before committing.
To enable this pre-commit hook, run$pre-commitinstall
Package: argus-ticket-gitlab
argus_ticket_gitlabThis is a plugin to create tickets in Gitlab fromArgusSettingsTICKET_ENDPOINT:"https://gitlab.com/"or link to self-hosted instance, absolute URLTICKET_AUTHENTICATION_SECRET: Create aproject access tokenor apersonal access tokenwith the scopeapi:{
    "token": token
}It is recommended to create a Gitlab API user and to ensure that that user
has the necessary authorization for creating issues in the relevant
repository.TICKET_INFORMATION:Project namespace and name (obligatory){
    "project_namespace_and_name": project_namespace_and_name
}To know which project to create the ticket in the Gitlab API needs to know
the owner and name of it.To figure out the namespace visit thenamespace pageof the Gitlab
documentation. The name is the name of the Gitlab project.For the Github projectSimple Maven Examplethe dictionary would look like this:{
   "project_namespace_and_name": "gitlab-examples/maven/simple-maven-example",
}Labels (optional)There are two ways of automatically filling labels:Labels that are always the same, independent of the incident.
These will be set inlabels_set.{
    "labels_set" : [
        label1,
        label2,
        label3,
    ]
}Labels that are filled by attributes of the Argus incident.
These are set inlabels_mappingwhich is a list of the names of the
attributes as they are returned by the API (e.g.start_time). If the
information can be found in the tags the it has to be a dictionary withtagas the key and the name of the tag as the value (e.g.
{"tag": "host"}).{
    "custom_fields_mapping" : [
        attribute_of_incident,
        {"tag": name_of_tag},
    ]
}Code styleargus_ticket_gitlab uses black as a source code formatter. Black can be installed
by running$pipinstallblackA pre-commit hook will format new code automatically before committing.
To enable this pre-commit hook, run$pre-commitinstall