Saravanan666/pypi-org huggingface dataset:
Package: pipedrive-python
[![Build Status](https://travis-ci.org/bellhops/pipedrive-python.svg?branch=master)](https://travis-ci.org/bellhops/pipedrive-python)
[![Documentation Status](https://readthedocs.org/projects/pipedrive-python/badge/?version=latest)](http://pipedrive-python.readthedocs.org)
[![Version](https://img.shields.io/pypi/v/pipedrive-python.svg)](https://pypi.python.org/pypi/pipedrive-python/)
[![License](http://img.shields.io/:license-mit-blue.svg)](http://badges.mit-license.org)
![Size](https://reposs.herokuapp.com/?path=Bellhops/pipedrive-python)pipedrive-pythonPython client for the Pipedrive API.
Package: pipeffmpeg
A frontend for ffmpeg(libav) using only pipes,
to encode/decode/convert videos by each frame,
not under GPL, but under BSD license.Features:get ffmpeg’s infomation (versions,codecs,formats,pix_fmts,…)decode frames from a videoencode a video within post frames in PythonYou can install and test pipeffmpeg as follows:download libav(ffmpeg) binary or source and build that
(not necessary as shared-library).set bin/ffmpeg or ffmpeg.exe(under Windows) into PATH environmentdownload pipeffmpeg.py to your current directory or site-packagesPlease report issues as well as configuration details for your working
PipeFFmpeg installations at <k.kanryu@gmail.com>Thus, your feedback is welcome at <k.kanryu@gmail.com>.
Package: pipefitter
The SAS Pipefitter project provides a Python API for developing
machine learning pipelines. The pipelines are built from stages
that perform variable transformation, parameter estimation, and
hyperparameter tuning.A key feature of pipefitter is that the pipelines can run
with a SAS 9.4 platform as well as with SAS Cloud Analytic
Services (CAS) in the SAS Viya platform.This package builds on the SASPy and SAS SWAT packages. Those
packages enable Python to work with SAS 9.4 and SAS Viya,
respectively.InstallationSAS pipefitter can be installed as follows withpip:pip install pipefitterAlternatively, you can install a specific release as follows:pip install https://github.com/sassoftware/python-pipefitter/releases/download/vX.X.X/pipefitter-X.X.X.tar.gzDependenciesThe package is a pure Python package and works with Python 2.7 or 3.4+.However, the packages that enable Python to work with the different
SAS platforms introduce dependencies of their own.PackageSAS PlatfomPython SupportSASPy 2.xSAS 9.4 or higherPython 3.xSWAT v1.1.0+SAS ViyaPython 2.7 or 3.4+ResourcesPipefitter documentationSASPySAS SWAT for PythonPython
Package: pipe-fn
Installpip installpipe-fnpipe-fnFunction transformation purely.frompipe_fnimporte# e is the identity mappingdefadd(this,other):returnthis+otherprint([1,2,3]|e/sum)# sum([1, 2, 3])# => 6print([2,3,-1]|e**{'key':lambdax:-x}/sorted)# set kwargs# sorted([2, 3, -1], key=lambda x: -x)# => [3, 2, -1]print([[1],[2],[3]]|e/sum*([],))# set args# sum([[1], [2], [3]], [])# => [1, 2, 3]defmy_func(self,*args,**kwargs):returnself,args,kwargsprint([1,2,3]|e**dict(a=1,b=2,c=3)# you should set kwargs first because of the high priority of `**` operator.*(4,5,6)# it'okay to change the order of setting `args` and setting `function`./my_func)# => ([1, 2, 3], (4, 5, 6), {'a': 1, 'b': 2, 'c': 3})print(1|e/add*(1,))# add(1, 1)# => 2defdouble(x):return2*x# and then compositionprint(1|(e/add*(2,)+double+double))# double(double(add(1, 2))# => 12 = (1 + 2) * 2 * 2# set single arg[['a'],['b']]|e/sum@[]\|e/print# print(sum([['a'], ['b']], []))# => [1, 2]defdouble(x):return2*x[1,2,3]|e/std.general.Sum@double\|e/print# print(Sum([1,2,3], double))# => 12
Package: pipeforce-sdk-python
PIPEFORCE Python SDKA library to simplify the communication with PIPEFORCE iPaaS from inside Python scripts.For more information about PIPEFORCE see:https://pipeforce.orgFor developer documentation of this SDK, see:https://pipeforce.org/sdk-python/index.htmlThis library can be used in FaaS / Lamda functions whereas Python is running as a Function inside PIPEFORCE,
in a microservice running inside PIPEFORCE or in a standalone Python application for example to connect
local services or OnPremise systems with PIPEFORCE.PrerequisitesPython >= 3.9 is installedPIPEFORCE >= 9.0.0
Package: pipefun
PipefunA simple, lightweighted, zero dependency python piping package.InstallpipinstallpipefunUsagefrompipefunimportPipable,outfrompipefun.Functionalsimportsquareadd_to=lambdaa:lambdab:a+b# a curried **add** functionoutput=~(x>>add_to(3)>>square)print(output)# 36The>>operator pushes aPipableinto a function and return a newPipablewith the return value of the function.
The~operator pulls the value in aPipableNote thatPipableisimmutable, so the returnedPipabledoesn't equal the input and is a new onex_out=x>>add_to(3)>>squareprint(x_out==x)# Falseprint(~x_out==~x)# FalsePipe mergingIn daily use case, it's very possible that functions take more than 1 arg. To handle this,Pipablecan store more than 1 values and plug them into a function when needed.We use the|operator to mergePipables. In Python, it has lower priority than>>.x=Pipable(3)y=Pipable(5)out=x>>square# Pipable(9)# merge two Pipables togetherout=out|y# Pipable(9, 5)# plug the pipes into a two args functionout=out>>add# Pipable(14)print(~out)# 14Alternatively, in one line.out=(x>>square|y)>>add# Pipable(14)print(~out)# 14Let's discard the~operatorThere is a special function in Pipable package that do nothing. If a Pipable is piped into it, same thing will happen with what the~operator do.frompipefunimportPipable,outx=Pipable(2)y=x>>square>>outprint(y)# 4
Package: pipeGEM
PipeGEM v0.1.0-alpha1This is a package for visualizing and analyzing metabolic models.
Also, it allows users to integrate omic data, metabolic tasks, and medium data with GEMs.
The analysis functions in the package are based on cobrapy:https://cobrapy.readthedocs.io/en/latest/How to get PipeGEMTo install directly from PyPI:pip install pipegemHow to use this packagesingle modelimportpipeGEMaspgfrompipeGEM.utilsimportload_modelmodel=load_model("your_model_path")# cobra.Modelpmodel=pg.Model(model)# Print out model informationprint(pmodel)# Do and plot pFBA resultflux_analysis=pmodel.do_flux_analysis("pFBA")flux_analysis.plot()multiple modelsimportpipeGEMaspgfrompipeGEM.utilsimportload_modelmodel_1=load_model("your_model_path_1")model_2=load_model("your_model_path_2")group=pg.Group({"model1":model_1,"model2":model_2})# Do and plot pFBA resultflux_analysis=group.do_flux_analysis("pFBA")flux_analysis.plot()Generate context-specific modelsimportnumpyasnpimportpipeGEMaspgfrompipeGEM.utilsimportload_modelfrompipeGEM.dataimportGeneData,synthesis# initialize modelmod=pg.Model(load_model("your_model_path_1"))# create dummy transcriptomic datadummy_data=synthesis.get_syn_gene_data(mod,n_sample=3)# calculate reaction activity scoregene_data=GeneData(data=dummy_data["sample_0"],# pd.Series or a dictdata_transform=lambdax:np.log2(x),# callableabsent_expression=-np.inf)# valuemod.add_gene_data(name_or_prefix="sample_0",# name of the datadata=gene_data,or_operation="nanmax",# alternative: nansumthreshold=-np.inf,absent_value=-np.inf)# apply GIMME algorithm on the modelgimme_result=mod.integrate_gene_data(data_name="sample_0",integrator="GIMME")context_specific_gem=gimme_result.result_model
Package: pipeGraph
IntroductionScikit-Learn’s Pipeline is a very useful tool to bind a sequence of transformers and a final estimator
in a single unit capable of working itself as an estimator. This eases managing the fit and predict
of the complete sequence of steps through a simple call to their fit and predict methods,
and in combination with the GridSearchCV function allows to tune the hyperparameters of these steps
while in the search for the best model.PipeGraph extends the concept of Pipeline by using a graph structure that can handle Scikit-Learn’s
objects in imaginative layouts. This allows the user to:Express simple and complex sequences of steps, from linear workflows to elaborated graphsTo have access to all the data generated along the intermediate stepsTo use GridSearchCV on those graphsLet’s see a few examples to understand how we can express these situations through PipeGraph objects.LICENSEThe MIT License (MIT)Copyright (c) 2018 Laura Fernandez Robles,Hector Alaiz Moreton,
Jaime Cifuentes-Rodriguez,
Javier Alfonso-Cendón,
Camino Fernández-Llamas,
Manuel Castejón-LimasPermission 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: pipeish
initially was named after a friend from school, Pavel Hurgcheev - `pash`. then`psh`. until free name was found - `pipeish`.it's like pipes in shell but not exactly. hence `pipe-ish`.[picture-of-python-looking-like-a-shell]it is still raw and WIP but mostly behaves like you running commands in shell.How to use-----for installed package:```from pipeish import Shell```for development (replace `os.getcwd()` with path to pipeish sources)```import os; import sys; sys.path.insert(0, os.getcwd())from pipeish import Shell```Examples-----simple as it is:```_()('ls')_()('ls -la | head -3')  # single string with '|' in shell-like way```it uses `str.split('|')` under the hood, so if your arguments contain `|`s you can feed comma separated list instead.```_()('gzcat stagedb.sql.gz', 'psql -U usermane pentagon_db')```if you need fancy redirections provide tuple (or list) with redirection options instead of string.options are always two characters, first for `stdout` and second for `stderr`.for example, 'nt' means "redirect stdout to /dev/null and don't redirect stderr".there is a special variant for each stream, 'd', which means 'default behaviour'.by default `pipeish` tryies to do what you expect from the same command when it runs in shell.```_()(['ls -la', 'nt'],('grep Pip', 'dd'))```but none of these will cope with exit codes.for this to work use `Shell` as context manager:```with Shell() as _:_('true | false')```now your python script will exits with the same exit code as bash script with same commands. but it will exit right after exiting `with` scope. nothing below context manager will be executed. to disable this behaviour there is `check` argument:```with Shell(check=False) as _:_('true | false')print (_.last_retcode)```this way you can run different `Shell`s in one script which allows more complicated scenarios.to capture outout of command you have to set 'i' option for stdout of last command:```with Shell() as _:out, err, exit_code = _(['uname -a', 'id'])```this looks a bit inconvenient, but this is best replacement for POSIX shell redirection syntax I came up so far.in this example:1. output will be captured into `out` and will not be printed in terminal.similiar to when you do `out = $(uname -a)` in bash, but here you can capture all two streams along with exit code in one call.2. errors will be printed into terminal and will not be captured. which is happening when you forget to set redirect `2>&1` or `2>/dev/null` in bash script.you can totally do it by the way in `pipeish` with respective options `r` or `n` for stderr ('ir' or 'in' for this example).3. `exit_code` will contain exit code of _last_ command. which is you kinda expect when running chain of commands.more are comming!feel free to open issues with common use cases, I'll try to prioritizewhat seems important and integrate.Links-----"Bash is the JavaScript of systems programming". Strongly agree.https://github.com/progrium/bashstyle"shell=True: Security Considerations"https://docs.python.org/3/library/subprocess.html#security-considerations
Package: pipeit
pipeitThis is a super simple wrapper , let's use python functional programming like Unix pipe!Inspired byabersheeran/only-pipe,czheo/syntax_sugar_python,pipetoolsInstallpip install pipeitUsageStatements start withPIPEand end withENDORyou can even ellipsis them.There're only two objects(PIPE&END) and three types(Filter,Map&Reduce) in namespace, so feel free to usefrom pipeit import *.Convert filter into tuple or capital the first letter, e.g.map(lambda x:x + 1) => (map , lambda x:x + 1)orMap(lambda x:x + 1), howeverDO NOT MIX USE THEM.It'll be 10% ~ 20% faster using the original python functional way than using these wrappers.v0.2.0 Update:Simple code timing meansv0.3.0 Update:Easier reading and writing operationsExampleBasic useage:>>>frompipitimportPIPE,END,Map,Filter,Reduce>>>data=PIPE|range(10)|(map,lambdax:x+1)|(map,str)|list|END>>>data['1','2','3','4','5','6','7','8','9','10']# (map , lambda x:x + 1) equals to Map(lambda x:x + 1)>>>func=lambdax:PIPE|range(x)|Map(lambdax:x+1)|Map(str)|list|END>>>func(10)['1','2','3','4','5','6','7','8','9','10']Or you may want a more easy use.>>>range(10)|Filter(lambdax:x<5)|list[0,1,2,3,4]>>>for_inrange(3)|Map(str):print(repr(_))'0''1''2'Code timer updated in version 0.2.0, you can easily detect the execution time of code blocks or statements.frompipeitimport*fromfunctoolsimportreducefoo=list(range(100))for_intimeit(1e6):# which means loop for 1m timesbar=foo|Filter(lambdax:x%3)|Map(lambdax:10*x)|Reduce(lambdax,y:x+y)|intwithtimeit():# a handwritten for loop is required under context manager modefor_inrange(int(1e6)):bar=reduce(lambdax,y:x+y,map(lambdax:10*x,filter(lambdax:x%3,foo)))# output:# [line 5][approximate] time cost / loop: 9.8967234μs# [line 8][exact] time cost: 7.0519098sBetter IO functions are updated in version 0.3.0. If you hate typing encoding="utf-8" over and over again, believe me, you'll love them.Use simpleRead()/Write()/ReadB()/WriteB()functions instead of the default practice ofwith open(). You can specify the encoding format, but they are specified asutf-8by default. Another advantage of doing this is that you no longer need to worry about accidentally emptying the file by not changing 'w' to 'r'.frompipeitimport*importjson#Write("a.txt","Hello World!")WriteB("b.json","[1, 2, 3]".encode("utf-8"))assertRead("a.txt")=="Hello World!"assertReadB("b.txt")==b"[1, 2, 3]"Similarly, you can use pipes to send data to them, or pipes to receive data from them.# OR"[1, 2, 3]".encode("utf-8")|WriteB("b.json")# another typical scenario is to cache data to hard disk and read it back againhtml_a="abc"# requests.get("https://a.example.com").texthtml_b="123"# ...htmls={"html_a":html_a,"html_b":html_b}json.dumps(htmls)|Write("htmls.json")#htmls=Read("htmls.json")|json.loadshtml_a,html_b=htmls.values()>>and|operands are functionally identical while doing IO."Hello World!" >> Write("a.txt")
text = Read("a.txt") >> str
assert text == "Hello World!"
Package: pipekit
PipekitPipekitis aflow-basedprogramming toolkit, with a control layer.Quick startPipekit connects message processors using pipes. Pipes are just a thin layer on
top ofQueueobjects and0mqsockets, wrapping them under a common API. The
basic idea behind this abstraction is the possibility to transparently replace
a pipe implementation with another one, with no code change needed in the
producers/consumers.Pipes simply have an input and an output channel; creating and using them is
pretty straightforward:frompipekitimportThreadPipe# Pipes need to be given a namemypipe=ThreadPipe('my-pipe')mypipe.send('Hello world')print(mypipe.receive())# Hello worldPipes are iterables, too:formsginmypipe:dosomething(msg)Need a 0mq-based pipe instead?frompipekitimportZMQPipemy0mqpipe=ZMQPipe('my-0mq-pipe',address='tcp://*:5555')Alternatively:frompipekitimportPipemy0mqpipe=Pipe('my-0mq-pipe',impl='zmq',address='tcp://*:5555')print(my0mqpipe)# <pipekit.ZMQPipe object at 0x7fe...>
Package: pipekit-sdk
Pipekitallows you to manage your workflows at scale. The control plane configures Argo Workflows for you in your infrastructure, enabling you to optimize multi-cluster workloads while reducing your cloud spend.  The team at Pipekit is also happy to support you through your Argo Workflows journey via commercial support.Pipekit Python SDKInstallationpipinstallpipekit-sdkUsagefromhera.workflowsimport(DAG,Parameter,Script,Workflow,)frompipekit_sdk.serviceimportPipekitService# Create a Pipekit service that is used to talk to the Pipekit APIpipekit=PipekitService(token="<Bearer Token>")# List clusters and Pipesclusters=pipekit.list_clusters()pipes=pipekit.list_pipes()# Create a Workflow and submit it to Pipekit.# Hera's dag-diamond exampledefmy_print_script(message):print(message)defget_script(callable):# Note that we have the _option_ to set `inputs=Parameter(name="message")`, but# Hera infers the Parameters that are necessary based on the passed-in callable.returnScript(name=callable.__name__.replace("_","-"),source=callable,add_cwd_to_sys_path=False,image="python:alpine3.6",)withWorkflow(generate_name="dag-diamond-",entrypoint="diamond",namespace="default",)asw:echo=get_script(my_print_script)withDAG(name="diamond"):A=echo(name="A",arguments=[Parameter(name="message",value="A")])B=echo(name="B",arguments=[Parameter(name="message",value="B")])C=echo(name="C",arguments=[Parameter(name="message",value="C")])D=echo(name="D",arguments=[Parameter(name="message",value="D")])A>>[B,C]>>D# Submit the Workflow to Pipekitpipe_run=pipekit.submit(w,"<cluster-name>")# Tail the logspipekit.print_logs(pipe_run["uuid"])Further helpPlease refer to thePipekit Documentationfor more information.
Package: pipelane
PipelanePipelane is a client side of continuous integration/build system on top of REST api. Pipelane will integrate existing systems as many as possible, such as JIRA, Jenkins, etc.Actionstimestep (ts) - to time the build step;
systemsnap (ss) - to snapshot the system info (cpu, mem, path, os, etc.);
dependencymap (dm) - to record the dependencies with their version;SubsystemsStorage - store files/artifacts, as an adapter to Nexus / Artifactory;
Ticket - create Epic/story/tasks, add comments; interact with human, e.g. waiting for a decision;
Document - change logs, store links, aggregate the related information;
Log - store, analyse, search logs;
Pod - remote resource for build;
Notification - chatbot or other systems on top of Hipchat or Slack to receive notifications, send commands;
UI - simple UI to collect, simplify inputs;
Repo - interact with repo server, checkin, checkout, create branches, merge branches, review change, etc.;Supportive systemsWebhook
CI/System
Github/Gitlab/Gerrit
Storage servers, such as Nexus, ArtifactoryGithub-flavored Markdown
Package: pipelayer
PipeLayerPipeLayer is a event-driven pipeline framework. Define a series of steps, and chain them together to create modular applications.Table of ContentsInstallationGetting StartedThe FrameworkComplete documentation can be found here:greaterthan.solutions/pipelayerInstallationFrom the command line:pipinstallpipelayerGetting StartedStep 1: Create The Filtershello_world_filters.pyfrompipelayerimportFilterclassHelloFilter(Filter):defrun(self,data,context):return"Hello"classWorldFilter(Filter):defrun(self,data,context):returnf"{data}, World!"functions.pydefcreate_message(data,context):return{"message":data}Step 2: Create The PipelineCreate a module to run the pipeline:app.pyimportjsonfrompipelayerimportPipelinefrompipelayer.utilimportrender_manifestfromfunctionsimportcreate_messagefromhello_world_filtersimportHelloFilter,WorldFilterif__name__=="__main__":hello_world_pipeline=Pipeline([HelloFilter,WorldFilter,create_message,lambdadata,context:json.dumps(data),])output=hello_world_pipeline.run(None)# output = '{"message": "Hello, World!"}'print("\nPipeline Output:")print(output)print("\nManifest:")print(render_manifest(hello_world_pipeline.manifest))Step 3: Run the Pipelinefrom the command line:runapp.py
Package: pipeless-ai
Pipeless CorePipelessis a computer vision framework to quickly create and deploy applications that process real time streams. The Pipeless Core is the core component of the framework.The Pipeless core is split into several components:input: Receives the media streams, demux and decode the streams.worker: Receives raw media frames, either audio or video frames, and processes them according to the user provided appoutput: Receives the processed raw media frames, encodes and mux them into the proper container format for the output protocol provided by the userSystem DependenciesGstreamer 1.20.3. Verify withgst-launch-1.0 --gst-version. Installation instructionsherePython dependenciesPoetry: find the installation instructionshereInstallationpip install pipeless-aiDevelopmentTo test your changes run the following command from the project root directory:python -m pipeless_ai.core <component> [app_file_path.py]<component>can beinput,worker,output, orall(default)app_pathis required for theworkercomponent and must be the path to theapp.py(includingapp.py)For simplicity, it will load a mock configuration (hardcoded) atsrc/pipeless/pipeless.pythat you can edit for your use case.
The hardcoded configuration will only be used when launching the components with the command above, it won't affect testing with the CLI.In order to debug, you can set the configurationlog_leveltoDEBUG.
If you find an error related to GStreamer and no useful information has been logged, try using the env varGST_DEBUG=5to enable GStreamer to debug logs. Refer to thispagefor more information about GStreamer debugging.Manual TestingIn order to test your changes, start the virtualenv:poetry shellAfter that, go to theclidirectory and runpoetry installto install thepipeless-ai-cli(CLI) component.
Then go to thecoredirectory and runpoetry installto install thepipeless-aimodule. This will override the upstream dependency from the CLI component to use your local one.Verify your environment by ensuring the pipeless modules are pointing to your local directories instead of the PyPi public modules:pip list | grep pipelessWith that, you should be able to runpipeless runwith your changes.
Package: pipeless-ai-cli
Pipeless CLIPipeless is a framework to build and deploy multimodal perception apps in minutes without worrying about multimedia pipelines.
Pipeless CLI is the CLI component of the framework.InstallRun the following command:pip install pipeless-ai-cliUsagepipeless --helpSee the main docs for thegetting startedguide.DevelopmentWe usepoetryto manage dependencies.The CLI depends on the core component. Both components are released separately.Thecommandsdirectory contains all the commands that the CLI supports.
Thetemplatesdirectory contains default application templates that users can select for their app scaffolding.
Package: pipeless-ai-plugins
Pipeless PluginsIMPORTANT: THIS MODULE IS DEPRECATED IN FAVOR OF THE NEW PLUGIN SYSTEM
Check theplugins docsfor more information about the new plugin system.Pipelessis an open source multimedia framework with focus on computer vision.This package contains a list of usefull plugins to use when building applications with Pipeless.Plugin ListKafka: easily export data to Kafka topics