Saravanan666/pypi-org huggingface dataset:
Package: cmds-helper
CMDS HelperThis modul will help us to automate CLI Command we usually use in projects.InstallationUsing pip :pip install cmds-helperHow To UseInstall cmds-helper module usingpipMake runner file in root of your project files directory (i.erun.py)--ProjectDir
    --{{Your project files/folder}}
    --run.py
    --{{your cmd json file}}cmd.jsonImport cmdshelperHelperclassfromcmdshelper.helperimportHelperInstantiate theHelperclasscmd=Helper()Make command json file. You can make many cmd json file for grouping cmd or just make 1 cmd json file. The program will read all json file ends withcmd.jsonin your project directory and add it tolist_commandinHelperclass. The syntax is :{"{your_cmd_identifier}":["{cmd_command_to_run}","{cmd_command_to_run}",...],"{your_cmd_identifier}":["{cmd_command_to_run}","{cmd_command_to_run}",...],...}{your_cmd_identifier}is identifier for calling all cmd command under that identifier. every identifier must be uniquecmd_command_to_runis the cmd command you want to run. The command is string you usually type in CLI, but in the json file, you separate every command/optional/arguments using space / ' ' like usual.Incmd_command_to_run, you can add argument to pass, with type%{i}(iis index arguments passes)Example :"gitACP":["git add .","git commit -m %1","git push"]the identifier to call that command isgitACP(command to call git common command[add, commit, and push]). under that identifier, we specify all command we want to call"git add .""git commit -m "{message}" "is typed"git commit -m %1"%1means that the first argument passed when calling that command identifier, will replacing%1into the passed stringIf you just want add same commit message for each commit, you can just change%1into your message likefeat: add something"git push"You can see another command examples inexample_cmd.jsonThere are 4 ways to run thisfile, by CLI with passingarg, by hardcode the command inscript, or by usingpython -mCLI Passing argument :After instantiate the class, you can type this code :importsyscmd.run(sys.argv[1:])To run it, you just need to run the file and passing thecommand identifierandargumentif neededExample run it in CommandPromptpyrun.pygitACP"feat: add somethingthat will call thegitACPcommand and passfeat: add somethingas commit messageHardcoded Command :After instantiate the class, you can type this code :cmd.run([{yourcommandhere}])Example :cmd.run(["gitACP","feat: add something"])to run it, you just need to runrun.pyfileStraight from Python moduleIt is just as simple as you open the folder that you want to run the commandpython -m cmdshelper [command] [args_1] [args_2] ... [args_3]for example:python -m cmdshelper gitACP "feat: add something"Simply just cdmshelperIt is just as simple as you open the folder that you want to run the commandcmdshelper [command] [args_1] [args_2] ... [args_3]for example:cmdshelper gitACP "feat: add something"Full code inrun.pywill be :fromcmdshelper.helperimportHelperimportsyscmd=Helper()# run using clicmd.run(sys.argv[1:])# run using hardcode command#cmd.run(["gitACP","feat: add something"])LicenseThis project is licensed under the terms of the MIT license.
Package: cmdssh
Execute commands on local machine and on remote machine via ssh, and a
wrapper for paramikos scp.shell commandWrapper around subprocess.call with shell=Trueshell(cmd)Background Unix command runningRuns a blocking unix command and returns the resultcmd_run(cmd,pr=False,streamoutput=True,returnoutput=True,cwd=None,prefix=None)# examplecmd_run('date "+%Y-%m-%d% %H:%M"',pr=False,streamoutput=False,returnoutput=True)# more paramscall_command(command,cmdfolder=os.getcwd(),verbose=False,streamoutput=True,\returnoutput=False,prefix=None,ret_and_code=False)Parameters:command: unix commandcmdfolder=os.getcwd() -> working folder commandverbose=False -> prints the commandstreamoutput=True -> prints output to stdout (keeps buffering)returnoutput=False -> return the buffered outputprefix=None -> string to place before streaming outputret_and_code=False -> return exit code also (code, val)Variant background unix commandCommon usecase scenario, run a command and get the result, possibly
print to the console using an optional filter.# example filter:defonlyerrors(data):if"ERROR"indata:returndatacmd_exec(cmd,cmdtoprint=None,display=True,myfilter=onlyerrors)cmdtoprint: unix commanddisplay: print to consolemyfilter: function used to printSSH: run command on remote machineUses ssh and key authentication to logon to a remote ssh server and
execute a command there.defremote_cmd(server,cmd,username=None,timeout=60,keypath=None):#exampleremote_cmd("localhost","rm -Rf ~/Desktop/foobar")Parameters:server: ip or domain name of servercmd: unix command to executeusername: username used to logintimeout: try time to connect to serverkeypath: path to the public key of usernametuplebased interface:remote_cmd_map(servercmd)servercmd: tuple with ( server, cmd, username, keypath )SSH: Secure Copy Protocolscp_get(server,fp1,fp2,username=None,keypath=None)scp_put(server,fp1,fp2,username=None,keypath=None)Parameters:server: ip or domain name of serverfp1: source filepathfp2: target filepathusername: username used to loginkeypath: path to the public key of usernameSSH: ShellInvoke a shell on a machineinvoke_shell(server,username,keypath)Parameters:server: ip or domain name of serverusername: username used to loginkeypath: path to the public key of usernameDownload fileWrapper around the requests library. Downloads a file with a progress
bar.download(url,mypath):parameters:url: url to downloadmypath: filepath where to create the downloaded fileexample output:download:http://download.thinkbroadband.com/5MB.zip00:00:02|███████████████████████|3.7Mi/5.0Mi
Package: cmdstancache
Quicker model iterations and enhanced productivity for Stan MCMC bycaching model compilation in a smart waycaching sampling results in a smart wayNo waiting for the resampling the same model with the same data.InstallFirst installCmdStanPyand
CmdStan and make sure it works.$ pip install cmdstancacheUsagemodel = """
data {
  int N;
}
parameters {
  real<lower=-10.0, upper=10.0> x[N];
}
model {
  for (i in 1:N-1) {
         target += -2 * (100 * square(x[i+1] - square(x[i])) + square(1 - x[i]));
  }
}
"""
data = dict(N=2)

import cmdstancache

stan_variables, method_variables = cmdstancache.run_stan(
        model,
        data=data,
        # any other sample() parameters go here
        seed=42
)Now comes the trick:If you run this code twice, the second time the stored result is read.If you add or modify a code comment, the same result is returned without having to rerun.How it workscmdstancache keeps a cache of code and data that has previously been used for MCMC sampling.
If it already has the results, it returns it from the cache.Here are the details:The code is normalised (stripped of comments and indents)A hash of the normalised code is computedThe model code is stored in ~/.stan_cache/<codehash>.stanThe model is compiled, if it is not already thereThe data are sorted by key, exported to json, and a hash computedThe data are stored in ~/.stan_cache/<datahash>.jsoncmdstanpy MCMC is run with code=<codehash>.stan and data=<datahash>.jsonfit.stan_variables() and fit.method_variables() are returnedjoblib memoizes steps 7 and 8, avoiding resampling when the same data and code hash are seen.PlottingMake a quick corner plots of only the scalar model variables:cmdstancache.plot_corner(stan_variables)In case some chains are stuck, and you want to remove their samples for plotting:cleaned_variables = remove_stuck_chains(stan_variables, method_variables)
plot = plot_corner(cleaned_variables)Since this is optional, the dependency of corner is pulled in if installed with:$ pip install cmdstancache[plot]Contributors@JohannesBuchnerContributions are welcome.
Package: cmdstanjupyter
CmdStanJupyterCmdStanJupyteris a package to help development of Stan models (usingCmdStanPy)
in jupyter notebooks.Use it withjupyterlab-stan-highlightto recieve
highlighting for your%%stanblocks in python notebooks!The package is heavily based on Arvinds-dsjupyterstanpackage, but provides an
interface that simply returns acmdstanpy.CmdStanModelobject.FeaturesCompile a stan model and save it as a cmdstanpy variable by running a%%stancellDisplay and load an existing stan file with%stanfInstallationTo install the library:pipinstallcmdstanjupyterThis does not install cmdstanpy by default, as therecommended installationfor that package is via conda. If you want to install cmdstanpy via pip alongside
this package, usepipinstallcmdstanjupyter[all]UsageTo use themagicin your notebook, you need to lead the extension:%load_extcmdstanjupyterTo define a stan model inside a jupyter notebook, start a cell with the%%stanmagic. You can also provide a variable name, which is the variable name that
thecmdstanpy.CmdStanModelobject will be assigned to. For example:%%stanparis_female_birthsdata{intmale;intfemale;}parameters{real<lower=0,upper=1>p;}model{female~binomial(male+female,p);}When you run this cell,cmdstanjupyterwill create a cmdstanpy CmdStanModel object,
which will compile your model and allow you to sample from it.If the above code was stored in a filebirths.stan, the following is also possible:%stanf paris_female_births births.standata{intmale;intfemale;}parameters{real<lower=0,upper=1>p;}model{female~binomial(male+female,p);}To use your compiled model:fit=paris_female_births.sample(data={'male':251527,'female':241945},)
Package: cmdstanpy
CmdStanPyCmdStanPy is a lightweight pure-Python interface to CmdStan which provides access to the Stan compiler and all inference algorithms.  It supports both development and production workflows. Because model development and testing may require many iterations, the defaults favor development mode and therefore output files are stored on a temporary filesystem. Non-default options allow all aspects of a run to be specified so that scripts can be used to distributed analysis jobs across nodes and machines.CmdStanPy is distributed via PyPi:https://pypi.org/project/cmdstanpy/or Conda Forge:https://anaconda.org/conda-forge/cmdstanpyGoalsClean interface to Stan services so that CmdStanPy can keep up with Stan releases.Provide access to all CmdStan inference methods.Easy to install,minimal Python library dependencies: numpy, pandasPython code doesn't interface directly with c++, only calls compiled executablesModular - CmdStanPy produces a MCMC sample (or point estimate) from the posterior; other packages do analysis and visualization.Low memory overhead - by default, minimal memory used above that required by CmdStanPy; objects run CmdStan programs and track CmdStan input and output files.Source RepositoryCmdStanPy and CmdStan are available from GitHub:https://github.com/stan-dev/cmdstanpyandhttps://github.com/stan-dev/cmdstanDocsThe latest release documentation is hosted onhttps://mc-stan.org/cmdstanpy, older release versions are available from readthedocs:https://cmdstanpy.readthedocs.ioLicensingThe CmdStanPy, CmdStan, and the core Stan C++ code are licensed under new BSD.Exampleimportosfromcmdstanpyimportcmdstan_path,CmdStanModel# specify locations of Stan program file and datastan_file=os.path.join(cmdstan_path(),'examples','bernoulli','bernoulli.stan')data_file=os.path.join(cmdstan_path(),'examples','bernoulli','bernoulli.data.json')# instantiate a model; compiles the Stan program by defaultmodel=CmdStanModel(stan_file=stan_file)# obtain a posterior sample from the model conditioned on the datafit=model.sample(chains=4,data=data_file)# summarize the results (wraps CmdStan `bin/stansummary`):fit.summary()
Package: cmdstanpy-opencl
CmdStanPy with OpenCL and Multitreading CommandCmdStanPy is a lightweight pure-Python interface to CmdStan which provides access to the Stan compiler and all inference algorithms.  It supports both development and production workflows. Because model development and testing may require many iterations, the defaults favor development mode and therefore output files are stored on a temporary filesystem. Non-default options allow all aspects of a run to be specified so that scripts can be used to distributed analysis jobs across nodes and machines.CmdStanPy is distributed via PyPi:https://pypi.org/project/cmdstanpy/or Conda Forge:https://anaconda.org/conda-forge/cmdstanpyGoalsClean interface to Stan services so that CmdStanPy can keep up with Stan releases.Provide access to all CmdStan inference methods.Easy to install,minimal Python library dependencies: numpy, pandasPython code doesn't interface directly with c++, only calls compiled executablesModular - CmdStanPy produces a MCMC sample (or point estimate) from the posterior; other packages do analysis and visualization.Low memory overhead - by default, minimal memory used above that required by CmdStanPy; objects run CmdStan programs and track CmdStan input and output files.Source RepositoryCmdStanPy and CmdStan are available from GitHub:https://github.com/stan-dev/cmdstanpyandhttps://github.com/stan-dev/cmdstanDocsThe latest release documentation is hosted onhttps://mc-stan.org/cmdstanpy, older release versions are available from readthedocs:https://cmdstanpy.readthedocs.ioLicensingThe CmdStanPy, CmdStan, and the core Stan C++ code are licensed under new BSD.Exampleimportosfromcmdstanpyimportcmdstan_path,CmdStanModel# specify locations of Stan program file and datastan_file=os.path.join(cmdstan_path(),'examples','bernoulli','bernoulli.stan')data_file=os.path.join(cmdstan_path(),'examples','bernoulli','bernoulli.data.json')# instantiate a model; compiles the Stan program by defaultmodel=CmdStanModel(stan_file=stan_file)# obtain a posterior sample from the model conditioned on the datafit=model.sample(chains=4,data=data_file)# summarize the results (wraps CmdStan `bin/stansummary`):fit.summary()
Package: cmdstats
cmdstats查看你终端命令使用频率列表, 原理是通过宿主目录下的.*history分析后得到历史命令使用频率状态， 并且进行排序输出.Installpip install git+https://github.com/jackeyGao/cmdstats.gitUsage$ cmdstats -l 25
1   1919  27.01675%  vim
2   1524  21.45572%  python
3   797   11.22061%  ls
4   646   9.09475%   git
5   356   5.01197%   cd
6   215   3.02689%   ll
7   186   2.61861%   pip
8   82    1.15444%   rm
9   71    0.99958%   workon
10  66    0.92918%   mysql
11  61    0.85879%   clear
12  59    0.83063%   curl
13  56    0.7884%    ps
14  54    0.76024%   cat
15  43    0.60538%   tail
16  37    0.52091%   grep
17  36    0.50683%   echo
18  36    0.50683%   mv
19  35    0.49275%   sh
20  32    0.45051%   mkdir
21  29    0.40828%   nohup
22  29    0.40828%   cp
23  28    0.3942%    pwd
24  27    0.38012%   su
25  26    0.36604%   mkvirtualenvLicenseThe MIT License (MIT)Copyright (c) 2015 JackeyGaoPermission 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: cmdstyle
NOTE:This project is abandoned and unsupported.
Useargparseordocoptinstead.cmdstylecmdstyle is a library for creating command line interfaces using the command
style used by programs likesvnorhg.ExampleSample File:#! /usr/bin/env python3.2

import sys

import cmdstyle

class HelloCommand(cmdstyle.Command):
    'Print a greeting'

    name = cmdstyle.PosParam()
    shout = cmdstyle.Flag(
        description='Print the greeting in upper case',
        shortname='')
    exclamations = cmdstyle.Option(
        description='The number of exclamation marks used to end the '
                    'greeting',
        default=1)

    def __call__(self):
        #Note that the library does not do validations
        exclamations_int = int(self.exclamations)

        greeting = 'Hello'
        if self.name:
            greeting += ', ' + self.name
        if self.shout:
            greeting = greeting.upper()
        greeting += exclamations_int * '!'

        print(greeting)


class ByeCommand(cmdstyle.Command):
    'Print bye'

    def __call__(self):
        print('Bye!')


program = cmdstyle.Program(
    'sample.py',
    'Sample Program',
    'Just a sample program',
    'http://...')

program.register(HelloCommand())
program.register(ByeCommand())

if __name__ == '__main__':
    program.run(sys.argv)Sample Being Used:$ ./sample.py
Use `sample.py help` for usage.


$ ./sample.py help
usage: sample.py <command> [options] [args]

Sample Program
Just a sample program

Available commands:
  bye
  hello

Use `sample.py help <command>` for help on a specific command.
See http://... for additional information.


$ ./sample.py help hello
hello: Print a greeting
usage: hello NAME
Options:

   --shout             Print the greeting in upper case
-e --exclamations ARG  The number of exclamation marks used to end the greeting


$ ./sample.py hello
Hello!


$ ./sample.py hello --shout --exclamations 3
HELLO!!!
Package: cmdtest
cmdtest is a simple way to test command line programs.from cmdtest import Program, File

cat = Program('cat')

@cat.test
def cat_should_echo_single_file():
    assert cat(File('hello')).out == 'hello'

@cat.test
def cat_should_combine_files():
    assert cat(File('hello'), File('world')).out == 'helloworld'

if __name__ == '__main__':
    cat.run()InstallationAvailable from PyPI with eitherpiporeasy_install:$pipinstallcmdtest$easy_installcmdtestThis will also pull in the Attest dependencies.
Package: cmdtime
cmdtimeSimilar to the Linuxtimeutility for measuring how long a command takes to runUseful for the Windows Command PromptUses pure PythonNo point using this under LinuxNo need to install CygwinInstallationRequires Python 3.5+.Install from PyPi:python -m pip install cmdtimeUsage ExamplesTime a Python scriptcmdtime python whateverscript.pyTime anything elsecmdtime dirNotesFor some machine learning projects, I use the Windows command prompt to execute scripts. I use Windows so that Tensorflow can access my PC's NVIDIA GPU. (Unfortunately, using Linux under VirtualBox can't access GPUs.)In addition, there is no built-in equivalent of the Linuxtimeutility in the Windows 10 command prompt. Yes, there are other options such as those discussedhereandhere. But they either require installing old binaries that I'd rather avoid, or involve more cumbersome approaches. I wanted something where I can just prefix the command I want to run similar to the Linuxtimeutility.Hence the creation of this really trivial but useful Linuxtime-like utility which I'm callingcmdtime. And it's pure Python.Probably someone else has already created such a utility under PyPi, but I couldn't find it.Developer Notespython setup.py sdistWork in development mode:python -m pip install --editable .Push to TestPyPIpython -m twine upload --repository testpypi dist/*Push to PyPIpython -m twine upload dist/*Testing NotesTests are written to support both Windows and Linux, although this utility is not really needed in Linux.Installpytest:python -m pip install --upgrade pytestLocal testing:pytest -vTravis CI:Right now, Travis CI doesn't support Python on Windows, so this can only be tested on Linux.The tests only work on Python 3.7 or later as thesubprocess.run()had significant changes in parameters (capture_output,text) not available in earlier versions. While it's possible to create version-specific test code to be compatible with earlier versions, it's not worth the effort...
Package: cmdtools
cmdtoolsThis Python library implements a suite of tools used and/or developed in theComputational Molecular Designgroup of the Zuse Institute Berlin.InstallationInstall withpip install cmdtools(If you want to use the SLEPc library for sparse Schur decompositions install cmdtools with the extra slepc, i.e.pip install "cmdtools[slepc]")Contentspcca: An implementation of (generalized) PCCA⁺ using the Schur decompositionajc: A sparse implementation of the augmented jump chaindiffusionmaps: Diffusionmaps with sparse support and out of sample extensionsgalerkin: Trajectory based estimation of the transfer operator using a Galerkin projection onto Gaussian RBFsgillespie: Trajectory simulation from a generatornewton_generator: Multi-step estimation of the generator via the Newton polynomialpicking_algorithm: Given a set of datapoints, pick n points such that they are distributed as evenly / equidistant as possiblesqra: The Square Root approximation, estimating the generator for the diffusion in a given potentialvoronoi: Voronoi clustering of trajectories and estimation of the transfer operator with different metrics and center strategies.diffusion: A collection of dynamical systems (So far the double- and triple-well)
Package: cmdtools-py
cmdtoolsA (not quite) flexible command framework.Installationpip install --upgrade cmdtools-pyinstall latest commit from GitHubpip install git+https://github.com/HugeBrain16/cmdtools.gitBasic exampleimportasyncioimportcmdtools@cmdtools.callback.add_option("message")defsend(ctx):print(ctx.options.message)@send.errordeferror_send(ctx):ifisinstance(ctx.error,cmdtools.NotEnoughArgumentError):ifctx.error.option=="message":print("Message is required!")cmd=cmdtools.Cmd('/send hello')asyncio.run(cmdtools.execute(cmd,send))LinksPyPI project:https://pypi.org/project/cmdtools-pySource code:https://github.com/HugeBrain16/cmdtoolsIssues tracker:https://github.com/HugeBrain16/cmdtools/issuesDocumentation:https://cmdtools-py.readthedocs.io/en/latest
Package: cmdtrix
cmdtrixmatrix-console-effect made in Python.Explore the code »Report Bug·Request FeatureTable of ContentsAbout The ProjectMade WithGetting StartedPrerequisitesInstallationUsageExamplesLicenseContactAbout The ProjectThis project simply emulates "The Matrix"-effect on any console-terminal.Made With(back to top)Getting StartedPrerequisitesIt is necessary that a font is installed that supports the unicode characters used (greek, cyrillic).Installationinstall the python package (PyPI-cmdtrix):pip install cmdtrixpip install git+https://github.com/SilenZcience/cmdtrix.git(back to top)Usagecmdtrix [-h] [-c COLOR] ...python -m cmdtrix [-h] [-c COLOR] ...ArgumentDescription-h, --helpshow help message and exit-v, --versionoutput version information-s, --synchronoussync the matrix columns speed-c [*], --color [*]set the main-color to *-p [*], --peak [*]set the peak-color to *-d p, --dim padd chance p (percent) for dim characters-i p, --italic padd chance p (percent) for italic characters-m * p chide a custom message * within the Matrix, with chance p and color c-S *, --symbols *set a custom series of symbols to choose from-j, --japaneseuse japanese characters (overrides -S; requires appropriate fonts)--framedelay DELAYset the framedelay (in sec) to slow down the Matrix, default is 0.015--timer DELAYexit the Matrix after DELAY (in sec) automatically--onkeyonly spawn columns on key-pressExamplescmdtrix -m SilenZcience 5 red -m cmdtrix 5 blue -d 5 -m Star*The*Repo 10 magenta(back to top)LicenseThis project is licensed under the MIT License - see theLICENSEfile for detailsContactSilenZcience
Package: cm-duo
Gravity Interface (TK) - написанный на tkinter графический интерфейс, служащий для взаимодействия весовщика
и Gravity Core.v 0.2.4
- Иконка версии в углу
- ar_ip, ar_port, mirrored передаются как аргументы при запуске приложения
- добавлен cmadb (блокировка дублей)