Saravanan666/pypi-org huggingface dataset:
Package: client-of-redundant-servers
Client of redundant serversGeneric client of redundant servers. A simple framework to make requests of unreliable servers.
Throws an exception if no servers are available, otherwise returns a result from the first server that doesn't fail.
Supports round-robin, fixed, and random orders of servers.The intention is that you can use this to glue together things that are otherwise slightly tedious,
using your own client classes which inherit from ClientOfRedundantServers.Installationpip install client-of-redundant-serversUsageSay you have some web servers, all serving the same content, and you want to get a file from any one.
You don't care which server responds, but you don't want to have to manually look for failures and try again.client_of_redundant_serverslets you write things like this:importrequestsimportclient_of_redundant_serversascorsfromcollectionsimportOrderedDictclassClientOfRedundantWebServers(cors.ClientOfRedundantServers):def__init__(self,url_list:list):# Super().__init__ wants a dict, but this example is so simple that# a list can be used to create an OrderedDict of None.url_dict=OrderedDict((url,None)forurlinurl_list)super().__init__(url_dict)def_get_file_func(self,url):try:r=requests.get(url)# Check for errors that didn't raise a requests.exceptionifnotr.ok:raisecors.CurrentServerFailedreturnrexceptrequests.exceptions.RequestException:raisecors.CurrentServerFaileddefget_file(self):returnself.request(self._get_file_func)# Only picking on Ubuntu because it is widely mirrored.urls=["http://badserver.example.com/badfile","http://www.mirrorservice.org/sites/cdimage.ubuntu.com/cdimage/releases/16.04/release/SHA256SUMS","http://nl.archive.ubuntu.com/ubuntu-cdimages/16.04/release/SHA256SUMS"]client=ClientOfRedundantWebServers(urls)try:r=client.get_file()print(r.text)print("*****")print("Retrieved from : "+r.url)exceptcors.AllAvailableServersFailed:print("Error! No servers were available to service the request.")If you run that, you'll see that the client tries to retrieve the file frombadserver,
which fails, so it continues to try the next available server.See the "examples" directory for some examples that might be useful.
Currently there's a RADIUS client usingpyradand an Active Directory LDAP client usingldap3.
Package: client-render
# How to configure new ImageChoose AMI windows instance (for example, …) with GUIBoot from image by hand (for example on the t2.medium)Execute script (link), why it’s needed:disable antivirus (no required)disable firewall (no required)enable download files from internet (no required)set autoload with specific user (needs for the screenshots)add info to the regedit (DEFAULT_USER, DEFAULT_PASS)Disable Ctrl+Alt+Del at ConfigurationWindows SettingsSecurity SettingsLocal PoliciesSecurityadd bat file in the autoload folderadd ability to use user-data for the instanceadditional installations:install google chrome (no required)install notepad++ (no required)install python > 3.7create virtualenv in the c:venv3dsmaxInstall necessary environment and enter license:3DS MAXCorona rendererConfigure video driver for 3DS MAXShutdownSave the Image
Package: clients
Clients originally providedrequestswrappers to encourage best practices, particularly always using Sessions to connect to the same host or api endpoint. The primary goals were:provide aClientobject with a convenient constructorsupport a base url so that requests can provide a relative pathprovide the same interface for asyncioSince thenhttpxhas emerged as the successor torequests, and supports the above features natively. Soclients.Clientcan be replaced withhttpx.Clientfor most use cases. The project will continue to be maintained for additional features, such as theResourceobject.UsageTypicalrequestsusage is redundant and inefficient, by not taking advantage of connection pooling.r=requests.get('https://api.github.com/user',headers={'authorization':token})r=requests.get('https://api.github.com/user/repos',headers={'authorization':token})Using sessions is the better approach, but more verbose and in practice requires manual url joining.s=requests.Session()s.headers['authorization']=tokenr=s.get('https://api.github.com/user')r=s.get('https://api.github.com/user/repos')ClientClients make using sessions easier, with implicit url joining.client=clients.Client('https://api.github.com/',headers={'authorization':token})r=client.get('user')r=client.get('user/repos')ResourceResources extend Clients to implicitly handle response content, with proper checking of status_code and content-type.github=clients.Resource('https://api.github.com/',headers={'authorization':token})forrepoingithub.get('user/repos',params={'visibility':'public'}):...Resources also implement syntactic support for methods such asgetattrandcall, providing most of the benefits of custom clients as is.forrepoingithub.user.repos(visibility='public'):...Asynchronous variants of all client types are provided, e.g.,AsyncClient. Additional clients forRPC,GraphQL, and proxies also provided.Installation%pipinstallclientsDependencieshttpxTests100% branch coverage.%pytest[--cov]
Package: clients-scanner
clients-scannerLocal network clients scanner with deauth featureInfowhile creating app I was inspired by Android Fing applicationapplication shows local network devicesdiscovered devices are stored in clients.json file under home directoryapplication allows to perform deauthentication(disconnecting devices connected over WiFi)deauthentication bases on:https://github.com/roglew/wifikillicons by Icons8:https://icons8.com/sounds comes from:https://mixkit.co/Install.. code-block:: pythonpip install clients-scanneror.. code-block:: bashpip install git+https://github.com/streanger/clients-scanner.gitImportant: scapy requiresNpcap(https://npcap.com/#download) orWinpcap(https://www.winpcap.org/install/) on Windows andlibpcapon Linux. Please install needed package manuallyWindows:.. code-block:: bash# Npcap -> https://npcap.com/#download
# Winpcap -> https://www.winpcap.org/install/
# or Npcap included in nmap using command:
choco install nmap -yLinux.. code-block:: bashsudo apt-get install libpcap-devImportant: you may need to run script as sudo under Linux to work properlyUsageMain scanner gui.. code-block:: python# from Python
from clients_scanner import scanner
scanner().. code-block:: bash# from command-line
scannerScapyScanner.. code-block:: pythonfrom clients_scanner import ScapyScanner
scapy_scanner = ScapyScanner()

# get clients directly
clients = scapy_scanner.get_clients('192.168.0.1/24', timeout=2)
for (IP, mac) in clients:
    print(IP, mac)

# get enriched clients data from queue
scapy_scanner.run()
while True:
    item = scapy_scanner.clients_queue.get()
    print(item)
    # Client(mac='XXXX', ip='XXXX', bssid='XXXX', ssid='XXXX', time=XXXX)Deauthenticator.. code-block:: pythonfrom clients_scanner import Deauthenticator
deauth = Deauthenticator(gateway_ip='192.168.0.1', gateway_mac='aa:bb:cc:dd:ee:ff')
deauth.run()
victim_ip = '192.168.0.123'
victim_mac = 'aa:bb:cc:dd:ee:ff'
status = False
deauth.deauth_queue.put((victim_mac, victim_ip, status))Example view.. image::https://raw.githubusercontent.com/streanger/clients-scanner/master/images/scanner.pngChangelogv. 0.1.2reshaped guinight modescan on/off modedebug mode"removing clients" featurescrollable areamore friendly soundconfig files in user home directoryv. 0.1.0 - 0.1.1gui with limited rows numberdeauth featureIssuesIf you encounter anny issue, error, bug or you want to enchant project, please describe itin issues section <https://github.com/streanger/clients-scanner/issues>_
Package: client-throttler
Client ThrottlerOverviewA proactive rate-limiting tool utilizing Redis.Users can actively limit the call frequency of functions or methods, and calls that would cause exceeding the limit will
be delayed until they can be executed.Getting startedInstallation$pipinstallclient_throttlerUsage[Optional] Configure a default config for all Throttler rate limiters.fromredis.clientimportRedisfromclient_throttlerimportsetup,ThrottlerConfigsetup(ThrottlerConfig(redis_client=Redis(host="localhost",port=1234,db=1),rate="100/s"))Simply add a decorator to the function or method that needs to have its calls limited.fromredis.clientimportRedisfromclient_throttlerimportthrottler,ThrottlerConfig,Throttlerredis_client=Redis(host="localhost",port=1234,db=2)# use default config@throttler()deffunc_a(*args,**kwargs):returnargs,kwargs# use default config, and change custom config@throttler(ThrottlerConfig(rate="1/2s"))deffunc_b(*args,**kwargs):returnargs,kwargs# use default config, and change redis client and some custom config@throttler(ThrottlerConfig(rate="1/2s",redis_client=redis_client))deffunc_c(*args,**kwargs):returnargs,kwargs# change a callable into throttled callabledeffunc_d(*args,**kwargs):returnargs,kwargsfunc=Throttler(ThrottlerConfig(func=func_d))func(*args,**kwargs)[Optinal] get metric datafromredis.clientimportRedisfromclient_throttlerimportMetricManager,ThrottlerConfig,Throttlerredis_client=Redis(host="localhost",port=1234,db=2)deffunc_a(*args,**kwargs):returnargs,kwargs# enable_metric_record=True should be set when collect metricconfig=ThrottlerConfig(func=func_a,redis_client=redis_client,rate="100/s",enable_metric_record=True)func=Throttler(config)"""call your func"""metrics=MetricManager(config).load_metrics()LicenseBased on the MIT protocol. Please refer toLICENSE
Package: cli-essentials
CLI EssentialsEssential pieces of code aimed at making your Python projects a little bit better.Installation$ python -m pip install cli-essentialsUsagefromCLIimport<feature># This will import only one feature of your choosing# --or--fromCLIimport<feature1>,<feature2>,...# This will import as many features as you would like# --or--fromCLIimport*# This will import all CLI featuresFeature ListClearfromCLIimportclearprint("Hello World!")# "Hello World!" is printed to the consoleclear()# The console is clear againPrintfromCLIimportprint# This will not effect existing print functions in your programprint("Apple",color="red")# "Apple" is printed to the console with a Red foreground colorprint("Sky",color="blue",bcolor="white")# "Sky" is printed in Blue with a White background
Package: cliexercises
Linux CLI Text Processing ExercisesThis TUI application includes 60+ questions to test your CLI text processing skills.Note:This application is intended for exercises based on Linux CLI tools. You might still be able to solve the exercises on other platforms, but I'm not sure if it works.ScreenshotGuideSeeapp_guide.mdVideo demoYou can view a video demo here:https://youtu.be/0ggfQzXeYJgLicenseCode snippets are licensed underMIT LICENSEExercise questions and associated files (likequestions.json) are licensed underCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International License
Package: clifactory
Writing CLI isNOTfunny. Especially with all the
argument parsing and shit. This is why this module exists.Installing$pipinstallclifactory#!/usr/bin/env python# -*- coding: utf-8 -*-fromclifactoryimportCommandLineInterface,Argumentcli=CommandLineInterface()users=["John Doe","Dick Head"]@cli.endpoint(Argument('user',help='username to add'))defdo_user_add(args):users.append(args.user)printusers@cli.endpoint()defdo_user_list(args):printuserscli.parse()As shown in theexample.pyfile.You can run it like:$./exemple.pyuseraddusage:exemple.pyuseradd[-h]userexemple.pyuseradd:error:toofewarguments$./exemple.pyuseradd"foo bar"['John Doe','Dick Head','foo bar']Simple as that :)DocumentationSome more documentation is comming, stay tuned.Using the moduleYou have to import the components you need, which for now are:CommandLineInterfaceArgumentExclusiveGroupThen instanciate aCommandLineInterface:cli=CommandLineInterface()Then decorate your endpoint as follows:@cli.endpoint(Argument('argument',help="some help"),# positional argArgument('--user','-u')# optional argument)defdo_something(args):printargs# args is a argparse.Namespace objectYou can add as many arguments as you wish, the parameters
have to follow theargparse.add_argumentsyntax. Note
that your function’s name must be prefixed withdo_in
order for the parsing to work. It will just break the
name of the function into a “tree” where each_-delimited
word will be a leaf. So you can add more methods to your
‘user’ endpoint.Finally to parse something, just call:cli.parse()This will parse arguments fromsys.argv. Alternatively,
you may parse an arbitrary string:cli.parse("some string")I told you it does not have to be hard!LicenceCopyright (C) 2015  Thomas Maurice <thomas@maurice.fr>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
Package: cliff
Team and repository tagscliff – Command Line Interface Formulation Frameworkcliff is a framework for building command line programs.
It usesentry pointsto provide subcommands, output formatters, and other
extensions.Free software: Apache licenseDocumentation:https://docs.openstack.org/cliff/latest/Source:https://opendev.org/openstack/cliffBugs:https://storyboard.openstack.org/#!/project/openstack/cliffContributors:https://github.com/openstack/cliff/graphs/contributors
Package: cliffold
cliffoldAnalyze--helpoutputs of CLIs to generate programmatic client libraries.The ideacliffold scaffold-cli-lib git --dest=cliffold/gitThanks to--helpoutput, cliffold generates a Python library that can be used to interact with the CLI:fromcliffold.gitimportGitgit=Git()print(git.version)git.init()git.commit(message="Initial commit")To make this possible,cliffoldis currently in its research and collects CLI outputs.
Feel free to submit your CLI propositions with installation methods in#1.
Seecliffold_research.mdto check out the current research results.InstallationIf you want to……use this tool in your project 💻You might simply install it with pip:pipinstallcliffoldIf you usePoetry, then run:poetryaddcliffold…contribute tocliffold🚀[!Note]
If you use Windows, it is highly recommended to complete the installation in the way presented below throughWSL2.Fork thecliffold repositoryon GitHub.Install Poetry.Poetry is an amazing tool for managing dependencies & virtual environments, building packages and publishing them.
You might usepipxto install it globally (recommended):pipxinstallpoetryIf you encounter any problems, refer tothe official documentationfor the most up-to-date installation instructions.Be sure to have Python 3.8 installed—if you usepyenv, simply run:pyenvinstall3.8Clone your fork locally and install dependencies.gitclonehttps://github.com/your-username/cliffoldpath/to/cliffoldcdpath/to/cliffold
poetryenvuse$(cat.python-version)poetryinstallNext up, simply activate the virtual environment and install pre-commit hooks:poetryshell
pre-commitinstall--hook-typepre-commit--hook-typepre-pushFor more information on how to contribute, check outCONTRIBUTING.md.Always happy to accept contributions! ❤️Legal info© Copyright by Bartosz Sławecki (@bswck).This software is licensed under the terms ofMIT License.
Package: clifford
clifford: Geometric Algebra for Pythoncliffordis a numerical Geometric Algebra (a.k.a. Clifford algebra) package for python.Documentation:http://clifford.readthedocs.orgSource code:https://github.com/pygae/cliffordBug reports:https://github.com/pygae/clifford/issuesGeometric Algebra (GA) is a universal algebra which among several other independent mathematical systems, subsumes:Complex numbersQuaternionsLinear algebraScalars, vectors, and higher-grade entities can be mixed freely and consistently in the form of mixed-grade multivectors. Like this,Quick InstallationRequires Python version >=3.5Install usingconda:conda install clifford -c conda-forgeInstall usingpip:pip3 install cliffordDetailed instructionsQuickstartTry out a notebook inbinderOr have a go on your own pc:fromclifford.g3import*# import GA for 3D spacefrommathimporte,pia=e1+2*e2+3*e3# vectorR=e**(pi/4*e12)# rotorR*a*~R# rotate the vectorSyntax SummarySyntaxOperation|Symmetric inner product<<Left contraction^Outer product*Geometric productX(i)Return the section of the multivector X of grade iX(ei)Return the section of the multivector X for which ei is the pseudo scalarX[i]Return the i'th coefficient from the multivector XX.normal()Return the normalised multivector so that X*~X is +- 1For installation instructions, api documention, and tutorials,head over to our documentation!Citing This LibraryAs linked at the top of this page,cliffordis published to zenodo.
DOI10.5281/zenodo.1453978refers to all versions of clifford.To obtain BibTex citation information for aspecificrelease (recommended):Runpython -m pip show cliffordto determine which version you are using (or printclifford.__version__from python)Click on the corresponding version fromthis list of versionsScroll down to the bottom of the page, and click the "BibTex" link in the "Export" sidebarIf you want to cite all releases, use:@software{python_clifford,
  author       ={Hugo Hadfield and
                  Eric Wieser and
                  Alex Arsenovic and
                  Robert Kern and{The Pygae Team}},
  title        ={pygae/clifford},
  publisher    ={Zenodo},
  doi          ={10.5281/zenodo.1453978},
  url          ={https://doi.org/10.5281/zenodo.1453978}}
Package: cliffordlayers
Clifford LayersFor details about usage please seedocumentation.
If you have any questions or suggestions please open adiscussion. If you notice a bug, please open anissue.InstallationpipinstallcliffordlayersCitationIf you find our work and/or our code useful, please cite us via:@article{brandstetter2022clifford,title={Clifford Neural Layers for PDE Modeling},author={Brandstetter, Johannes and Berg, Rianne van den and Welling, Max and Gupta, Jayesh K},journal={arXiv preprint arXiv:2209.04934},year={2022}}@article{ruhe2023geometric,title={Geometric Clifford Algebra Networks},author={Ruhe, David and Gupta, Jayesh K and de Keninck, Steven and Welling, Max and Brandstetter, Johannes},journal={arXiv preprint arXiv:2302.06594},year={2023}}ContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visithttps://cla.opensource.microsoft.com.When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor
contactopencode@microsoft.comwith any additional questions or comments.TrademarksThis project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must followMicrosoft's Trademark & Brand Guidelines.
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.
Package: cliffs-delta
This is code to calculate the Cliff's Delta effect size metric, which strangely is not in NumPy/SciPy.stats.@Timm hadthis as a gist, and @mtorchiano hasR code with tests. I have merged them. Well, Marco's code does a lot more. I merged his tests.cliffs_deltaThe Cliff's Deltastatistic is a non-parametric effect size measure that quantifies the amount of difference between two groups of observations beyond p-values interpretation. This measure can be understood as a useful complementary analysis for the corresponding hypothesis testing.InstallationThis package can either be installed using pip or from a tarball using the standard Python distutils.If you are installing usingpip, you don’t need to download anything as the latest version will be downloaded for you from PyPI:pip install cliffs-deltaExample & UsageImport the methodcliffs_deltafromcliffs_deltafromcliffs_deltaimportcliffs_deltax1=[10,20,20,20,30,30,30,40,50,100]x2=[10,20,30,40,40,50]d,res=cliffs_delta(x1,x2)print(d,res)-0.06666666666666667negligible
Package: clifig
clifigClifig provides a very simple CLI for modifying config files.UsageClifig can be accessed directly from the terminal$clifigpath/to/config/file.conf(file.conf)of from a Python script>>>fromclifigimportClifig>>>Clifig.run('path/to/config/file.conf')(file.conf)Commandsshow [SECTION [OPTION]]Show the values for the provided section or optionadd SECTIONAdd a new section to the configset SECTION OPTION VALUESet a valuedel SECTION [OPTION]Delete a section or specific optionabortAbort all changesexit or Ctrl+DSafely exit and save all changesNotesI made this for another project and thought some people may find it useful.
It was primarily an exercise to learn about Python styling, packaging,
distribution, and open source licenses, but I do intend to maintain it.LicenseCopyright (C) 2013 Andrew GuentherPermission 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.
Package: cli_flask
## Flask CLI
This is cli (commond line interface) for Flask application based project.## Table of Contents## fl new
The flask cli makes it easy to create flask application .### Generating and starting an Flask project via a development server`bash fl new PROJECT_NAME cd PROJECT_NAME fl start `Navigate tohttp://localhost:5000/.# flask start
You can configure the default HTTP host and port used by the development server with two command-line options :`bash fl start--host0.0.0.0--port5001 `### Updating Flask CLI## LicenseMIT