| Name | pipelinechain JSON |
| Version |
1.0.1
JSON |
| download |
| home_page | None |
| Summary | A library that implements the Chain of Responsibility pattern. |
| upload_time | 2024-04-27 13:01:46 |
| maintainer | None |
| docs_url | None |
| author | Matthew Batchelder |
| requires_python | >=3.8 |
| license | MIT License Copyright (c) 2024 Matthew Batchelder Permission 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. |
| keywords |
pipeline
library
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# PipelineChain
[](https://github.com/borkweb/python-pipelinechain/actions?query=branch%3Amain)
A Pipeline / [Chain of Responsibility](https://refactoring.guru/design-patterns/chain-of-responsibility) design pattern implementation based on [Laravel's Pipeline implementation](https://github.com/illuminate/pipeline/blob/master/Pipeline.python).
A `Pipeline` is an object that accepts input data and _sends_ it through a series of handlers (or "pipes") — which are functions, closures, and/or classes — to get a result at the end.
```mermaid
flowchart LR
input[Input data]
subgraph Pipeline
pipe1[Pipe 1]
pipe2[Pipe 2]
pipe3[Pipe 3]
pipe1 --> pipe2
pipe2 --> pipe3
end
output[Output data]
input --> pipe1
pipe3 --> output
```
## Table of contents
* [Installation](#installation)
* [Getting started](#getting-started)
* [Creating a simple pipeline](#creating-a-simple-pipeline)
* [Building pipelines in parts](#building-pipelines-in-parts)
* [Using functions](#using-functions)
* [Using custom pipes](#using-custom-pipes)
* [Using classes with the `handle` method](#using-classes-with-the-handle-method)
* [Using classes with a custom method](#using-classes-with-a-custom-method)
* [Bailing early](#bailing-early)
* [Doing more than returning](#doing-more-than-returning)
* [Using a container in the pipeline](#using-a-container-in-the-pipeline)
* [Declaring pipelines for reuse](#declaring-pipelines-for-reuse)
* [Example](#example)
* [Service provider](#service-provider)
* [Response transporter](#response-transporter)
* [Intake_response](#intake_response)
* [Failed_response](#failed_response)
* [Listener](#listener)
* [Let's put it all together](#lets-put-it-all-together)
* [Methods](#methods)
* [`pipe()`](#pipe) (aliases: `add_pipe()`)
* [`send()`](#send)
* [`set_container()`](#set_container) (aliases: `setContainer()`)
* [`then()`](#then) (aliases: `run()`)
* [`then_return()`](#then_return) (aliases: `run_and_return()`, `thenReturn()`)
* [`through()`](#through) (aliases: `pipes()`)
* [`via()`](#via)
## Installation
Install PyPipeline via pip:
```bash
pip install pipelinechain
```
## Getting started
Luckily, there isn't a whole lot to Pipelines from a code perspective, so implementing them is pretty easy. We'll walk
through some of the basic concepts.
***Important note:** The examples provide a string as input data. That is just for simplicity's sake! You can
actually pass whatever you want - a scalar, an object, an array, whatever.*
### Creating a simple pipeline
Let's say you have a string that you want to pass through a series of steps in order to manipulate it. You can create a
pipeline to do that like so:
```mermaid
flowchart LR
input[String]
subgraph Pipeline
pipe1[title]
pipe2[trim]
pipe1 --> pipe2
end
output[Output data]
input --> pipe1
pipe2 --> output
```
```python
from pipelinechain import Pipeline
# Create a new pipeline instance.
pipeline = Pipeline()
# Send a string through the pipeline.
result = pipeline.send(' hello world ').through([
str.title,
str.strip
]).then_return()
print(result) # Output: 'Hello world'
```
### Building pipelines in parts
You don't need to build the pipeline all at once, you can spread it out over a number of lines.
```mermaid
flowchart LR
input[String]
subgraph Pipeline
pipe1[title]
pipe2[trim]
pipe3[reverse_string]
pipe1 --> pipe2
pipe2 --> pipe3
end
output[Output data]
input --> pipe1
pipe3 --> output
```
```python
from pipelinechain import Pipeline
# Create a new pipeline instance.
pipeline = Pipeline()
# Set the pipes you want to use.
pipeline.through([ str.title, str.strip ])
# Add another transformation.
def replace(s):
return s.replace('Hello', 'Goodbye')
# Add it to the pipeline.
pipeline.pipe(replace)
# Send data through the pipeline.
result = pipeline.send(' hello world ').then_return()
print(result) # Output: 'Goodbye World'
```
### Using custom pipes
If you have a more complicated function that you wish to use as a pipe, you can pass in a callable instead of a string.
Your closure will need to accept two parameters, the first being the input data and the second being the next item in the pipeline.
```mermaid
flowchart LR
input[String]
subgraph Pipeline
pipe1[custom_pipe]
pipe2[captialize]
pipe1 --> pipe2
end
output[Output data]
input --> pipe1
pipe2 --> output
```
```python
from pipelinechain import Pipeline
pipeline = Pipeline()
def custom_pipe(passable, next_pipe):
passable = passable.replace('hello', 'goodbye')
return next_pipe(passable)
pipeline.through([custom_pipe, str.title])
result = pipeline.send('hello world').then_return()
print(result) # Output: 'Goodbye world'
```
### Using classes with the `handle` method
You can even create your own classes to use as pipes in the pipeline. For a class to be usable in the pipeline, it needs
a method that accepts two parameters, the first being the input data and the second being the next item in the pipeline.
By default, the Pipeline expects that the method is called `handle`. If you want to use that method name, you can
optionally implement the `StellarWP\Pipeline\Contracts\Pipe` interface to enforce that method convention.
#### Example classes
First class:
```python
class TitlePipe:
def handle(self, passable, next_pipe):
return next_pipe(passable.title())
```
Second class:
```python
class StripPipe:
def handle(self, passable, next_pipe):
return next_pipe(passable.strip())
```
#### Example pipeline
```mermaid
flowchart LR
input[String]
subgraph Pipeline
pipe1[TitlePipe::handle]
pipe2[StripPipe::handle]
pipe1 --> pipe2
end
output[Output data]
input --> pipe1
pipe2 --> output
```
```python
from pipelinechain import Pipeline
pipeline = Pipeline().through([TitlePipe(), StripPipe()])
result = pipeline.send(' hello world ').then_return()
print(result) # Output: 'Hello world'
```
### Using classes with a custom method
If you want to use classes but want to use a different method than the expected default (`handle`), you can declare
the alternate method name using the `via()` method.
#### Example classes
First class:
```python
class TitlePipe:
def execute(self, passable, next_pipe):
return next_pipe(passable.title())
```
Second class:
```python
class StripPipe:
def execute(self, passable, next_pipe):
return next_pipe(passable.strip())
```
#### Example pipeline
```mermaid
flowchart LR
input[String]
subgraph Pipeline
pipe1[ReversePipe::execute]
pipe2[StripPipe::execute]
pipe1 --> pipe2
end
output[Output data]
input --> pipe1
pipe2 --> output
```
```python
from pipelinechain import Pipeline
pipeline = Pipeline().via('execute').through([StripPipe(), ReversePipe()])
result = pipeline.send(' hello ').then_return()
print(result) # Output: 'Hello'
```
### Bailing early
Sometimes in the middle of a pipeline, you want to stop processing the rest of the pipes and return a value. Luckily, you
can do this with a `return` statement!
#### Example pipeline
```python
from pipelinechain import Pipeline
def check_content(passable, next_pipe):
if 'stop' in passable:
return 'Early termination'
return next_pipe(passable)
pipeline = Pipeline().through([check_content, str.upper])
result = pipeline.send('please stop').then_return()
print(result) # Output: 'Early termination'
```
### Doing more than returning
Sometimes you may want to do more than returning the result when the pipeline completes. You can do that by
using the `then()` (or its alias, `run()`) method instead of `then_return()`.
#### Example pipeline
```mermaid
flowchart LR
input[String]
pipe3[Closure]
subgraph Pipeline
pipe1[strip]
pipe2[upper]
pipe1 --> pipe2
end
output[Output data]
input --> pipe1
pipe2 --> pipe3
pipe3 --> output
```
```python
from pipelinechain import Pipeline
pipeline = Pipeline().through([str.strip, str.upper])
result = pipeline.send(' hello world ').then(lambda x: len(x))
print(result) # Output: 11
```
## Methods
### `pipe()`
This method is used to add a pipe to the pipeline.
```python
def pipe(pipes: Union[List, Any]): Pipeline
```
*Aliases: `add_pipe()`*
#### Examples
```python
pipeline.pipe( str.strip )
# or
pipeline.add_pipe( str.strip )
# or
pipeline.pipe( [ str.title, str.strip ] )
```
### `send()`
This method is used to set the object being passed through the pipeline.
```python
def send( passable: Any ): Pipeline
```
#### Examples
```python
# Send a scalar.
pipeline.send( 'Some string' )
# Send an object.
pipeline.send( my_object )
```
### `then()`
This method is used to run the pipeline and return the result.
```python
def then( destination: Optional[Callable] = None ): Any
```
**Aliases:** `run()`
#### Examples
```python
pipeline.then()
# Use the alias.
pipeline.run()
# Provide a function to run before returning the result.
pipeline.then( str.strip )
# Provide a closure to run before returning the result.
pipeline.then( lambda passable: passable.strip() )
# Provide an object as a pipe to run before returning the result.
pipeline.then( StripPipe() )
```
### `then_return()`
This method is used to run the pipeline and return the result.
```python
def then_return(): Any
```
Aliases: `run_and_return()`, `thenReturn()`
#### Examples
```python
pipeline.then_return()
# Use an alias.
pipeline.thenReturn()
# Use the other alias.
pipeline.run_and_return()
```
### `through()`
This method is used to set the handlers (or "pipes") that are used to process the data.
```python
def through( pipes: Union[List, Any] ): Pipeline
```
Aliases: `pipes()`
#### Examples
```python
# You can provide any number of pipes.
pipeline.through([ str.title, str.strip ])
# Using the alias.
pipeline.pipes([ str.title, str.strip ])
# Pass closures as pipes.
pipeline.through([ str.title, lambda passable, next: next_pipe(passable.strip)])
# Pass objects as pipes.
pipeline.through([ TitlePipe(), StripPipe() ])
```
### `via()`
This method is used to set the method to call on all the pipes in the pipeline.
```python
def via( method: str ): Pipeline
```
#### Examples
```python
# Set the method used in all classes in the pipeline to process the data as `execute()`.
pipeline.via( 'execute' )
# Set the method used in all classes in the pipeline to process the data as `borkborkbork()`.
pipeline.via( 'borkborkbork' )
```
Raw data
{
"_id": null,
"home_page": null,
"name": "pipelinechain",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "pipeline, library",
"author": "Matthew Batchelder",
"author_email": "Matthew Batchelder <borkweb@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/d0/0c/fe6213884492ed11ca73f70304230a69b306687c35860dd21f817ea6f087/pipelinechain-1.0.1.tar.gz",
"platform": null,
"description": "# PipelineChain\n\n[](https://github.com/borkweb/python-pipelinechain/actions?query=branch%3Amain)\n\nA Pipeline / [Chain of Responsibility](https://refactoring.guru/design-patterns/chain-of-responsibility) design pattern implementation based on [Laravel's Pipeline implementation](https://github.com/illuminate/pipeline/blob/master/Pipeline.python).\n\nA `Pipeline` is an object that accepts input data and _sends_ it through a series of handlers (or \"pipes\") \u2014 which are functions, closures, and/or classes \u2014 to get a result at the end.\n\n```mermaid\nflowchart LR\n\tinput[Input data]\n\tsubgraph Pipeline\n\t\tpipe1[Pipe 1]\n\t\tpipe2[Pipe 2]\n\t\tpipe3[Pipe 3]\n\n\t\tpipe1 --> pipe2\n\t\tpipe2 --> pipe3\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe3 --> output\n```\n\n## Table of contents\n\n* [Installation](#installation)\n* [Getting started](#getting-started)\n * [Creating a simple pipeline](#creating-a-simple-pipeline)\n * [Building pipelines in parts](#building-pipelines-in-parts)\n * [Using functions](#using-functions)\n * [Using custom pipes](#using-custom-pipes)\n * [Using classes with the `handle` method](#using-classes-with-the-handle-method)\n * [Using classes with a custom method](#using-classes-with-a-custom-method)\n * [Bailing early](#bailing-early)\n * [Doing more than returning](#doing-more-than-returning)\n * [Using a container in the pipeline](#using-a-container-in-the-pipeline)\n * [Declaring pipelines for reuse](#declaring-pipelines-for-reuse)\n * [Example](#example)\n * [Service provider](#service-provider)\n * [Response transporter](#response-transporter)\n * [Intake_response](#intake_response)\n * [Failed_response](#failed_response)\n * [Listener](#listener)\n * [Let's put it all together](#lets-put-it-all-together)\n* [Methods](#methods)\n * [`pipe()`](#pipe) (aliases: `add_pipe()`)\n * [`send()`](#send)\n * [`set_container()`](#set_container) (aliases: `setContainer()`)\n * [`then()`](#then) (aliases: `run()`)\n * [`then_return()`](#then_return) (aliases: `run_and_return()`, `thenReturn()`)\n * [`through()`](#through) (aliases: `pipes()`)\n * [`via()`](#via)\n\n## Installation\n\nInstall PyPipeline via pip:\n\n```bash\npip install pipelinechain\n```\n\n## Getting started\n\nLuckily, there isn't a whole lot to Pipelines from a code perspective, so implementing them is pretty easy. We'll walk\nthrough some of the basic concepts.\n\n***Important note:** The examples provide a string as input data. That is just for simplicity's sake! You can\nactually pass whatever you want - a scalar, an object, an array, whatever.*\n\n### Creating a simple pipeline\n\nLet's say you have a string that you want to pass through a series of steps in order to manipulate it. You can create a\npipeline to do that like so:\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tsubgraph Pipeline\n\t\tpipe1[title]\n\t\tpipe2[trim]\n\n\t\tpipe1 --> pipe2\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe2 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\n# Create a new pipeline instance.\npipeline = Pipeline()\n\n# Send a string through the pipeline.\nresult = pipeline.send(' hello world ').through([\n str.title,\n str.strip\n]).then_return()\n\nprint(result) # Output: 'Hello world'\n```\n\n### Building pipelines in parts\n\nYou don't need to build the pipeline all at once, you can spread it out over a number of lines.\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tsubgraph Pipeline\n\t\tpipe1[title]\n\t\tpipe2[trim]\n\t\tpipe3[reverse_string]\n\n\t\tpipe1 --> pipe2\n\t\tpipe2 --> pipe3\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe3 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\n# Create a new pipeline instance.\npipeline = Pipeline()\n\n# Set the pipes you want to use.\npipeline.through([ str.title, str.strip ])\n\n# Add another transformation.\ndef replace(s):\n return s.replace('Hello', 'Goodbye')\n\n# Add it to the pipeline.\npipeline.pipe(replace)\n\n# Send data through the pipeline.\nresult = pipeline.send(' hello world ').then_return()\n\nprint(result) # Output: 'Goodbye World'\n```\n\n### Using custom pipes\n\nIf you have a more complicated function that you wish to use as a pipe, you can pass in a callable instead of a string.\nYour closure will need to accept two parameters, the first being the input data and the second being the next item in the pipeline.\n\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tsubgraph Pipeline\n\t\tpipe1[custom_pipe]\n\t\tpipe2[captialize]\n\n\t\tpipe1 --> pipe2\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe2 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\npipeline = Pipeline()\n\ndef custom_pipe(passable, next_pipe):\n passable = passable.replace('hello', 'goodbye')\n return next_pipe(passable)\n\npipeline.through([custom_pipe, str.title])\n\nresult = pipeline.send('hello world').then_return()\nprint(result) # Output: 'Goodbye world'\n\n```\n\n### Using classes with the `handle` method\n\nYou can even create your own classes to use as pipes in the pipeline. For a class to be usable in the pipeline, it needs\na method that accepts two parameters, the first being the input data and the second being the next item in the pipeline.\n\nBy default, the Pipeline expects that the method is called `handle`. If you want to use that method name, you can\noptionally implement the `StellarWP\\Pipeline\\Contracts\\Pipe` interface to enforce that method convention.\n\n#### Example classes\n\nFirst class:\n```python\nclass TitlePipe:\n def handle(self, passable, next_pipe):\n return next_pipe(passable.title())\n```\n\nSecond class:\n```python\nclass StripPipe:\n def handle(self, passable, next_pipe):\n return next_pipe(passable.strip())\n```\n\n#### Example pipeline\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tsubgraph Pipeline\n\t\tpipe1[TitlePipe::handle]\n\t\tpipe2[StripPipe::handle]\n\n\t\tpipe1 --> pipe2\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe2 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\npipeline = Pipeline().through([TitlePipe(), StripPipe()])\nresult = pipeline.send(' hello world ').then_return()\nprint(result) # Output: 'Hello world'\n```\n\n### Using classes with a custom method\n\nIf you want to use classes but want to use a different method than the expected default (`handle`), you can declare\nthe alternate method name using the `via()` method.\n\n#### Example classes\n\nFirst class:\n```python\nclass TitlePipe:\n def execute(self, passable, next_pipe):\n return next_pipe(passable.title())\n```\n\nSecond class:\n```python\nclass StripPipe:\n def execute(self, passable, next_pipe):\n return next_pipe(passable.strip())\n```\n\n#### Example pipeline\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tsubgraph Pipeline\n\t\tpipe1[ReversePipe::execute]\n\t\tpipe2[StripPipe::execute]\n\n\t\tpipe1 --> pipe2\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe2 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\npipeline = Pipeline().via('execute').through([StripPipe(), ReversePipe()])\nresult = pipeline.send(' hello ').then_return()\nprint(result) # Output: 'Hello'\n\n```\n\n### Bailing early\n\nSometimes in the middle of a pipeline, you want to stop processing the rest of the pipes and return a value. Luckily, you\ncan do this with a `return` statement!\n\n#### Example pipeline\n\n```python\nfrom pipelinechain import Pipeline\n\ndef check_content(passable, next_pipe):\n if 'stop' in passable:\n return 'Early termination'\n return next_pipe(passable)\n\npipeline = Pipeline().through([check_content, str.upper])\nresult = pipeline.send('please stop').then_return()\nprint(result) # Output: 'Early termination'\n\n```\n\n### Doing more than returning\n\nSometimes you may want to do more than returning the result when the pipeline completes. You can do that by\nusing the `then()` (or its alias, `run()`) method instead of `then_return()`.\n\n#### Example pipeline\n\n```mermaid\nflowchart LR\n\tinput[String]\n\tpipe3[Closure]\n\tsubgraph Pipeline\n\t\tpipe1[strip]\n\t\tpipe2[upper]\n\n\t\tpipe1 --> pipe2\n\tend\n\toutput[Output data]\n\n\tinput --> pipe1\n\tpipe2 --> pipe3\n\tpipe3 --> output\n```\n\n```python\nfrom pipelinechain import Pipeline\n\npipeline = Pipeline().through([str.strip, str.upper])\nresult = pipeline.send(' hello world ').then(lambda x: len(x))\n\nprint(result) # Output: 11\n\n```\n\n\n## Methods\n\n### `pipe()`\n\nThis method is used to add a pipe to the pipeline.\n\n```python\ndef pipe(pipes: Union[List, Any]): Pipeline\n```\n*Aliases: `add_pipe()`*\n\n#### Examples\n```python\npipeline.pipe( str.strip )\n# or\npipeline.add_pipe( str.strip )\n# or\npipeline.pipe( [ str.title, str.strip ] )\n```\n\n### `send()`\n\nThis method is used to set the object being passed through the pipeline.\n\n```python\ndef send( passable: Any ): Pipeline\n```\n\n#### Examples\n```python\n# Send a scalar.\npipeline.send( 'Some string' )\n\n# Send an object.\npipeline.send( my_object )\n```\n\n\n### `then()`\n\nThis method is used to run the pipeline and return the result.\n\n```python\ndef then( destination: Optional[Callable] = None ): Any\n```\n\n**Aliases:** `run()`\n\n#### Examples\n```python\npipeline.then()\n\n# Use the alias.\npipeline.run()\n\n# Provide a function to run before returning the result.\npipeline.then( str.strip )\n\n# Provide a closure to run before returning the result.\npipeline.then( lambda passable: passable.strip() )\n\n# Provide an object as a pipe to run before returning the result.\npipeline.then( StripPipe() )\n```\n\n### `then_return()`\n\nThis method is used to run the pipeline and return the result.\n\n```python\ndef then_return(): Any\n```\n\nAliases: `run_and_return()`, `thenReturn()`\n\n#### Examples\n```python\npipeline.then_return()\n# Use an alias.\npipeline.thenReturn()\n# Use the other alias.\npipeline.run_and_return()\n```\n\n### `through()`\n\nThis method is used to set the handlers (or \"pipes\") that are used to process the data.\n\n```python\ndef through( pipes: Union[List, Any] ): Pipeline\n```\n\nAliases: `pipes()`\n\n#### Examples\n```python\n# You can provide any number of pipes.\npipeline.through([ str.title, str.strip ])\n\n# Using the alias.\npipeline.pipes([ str.title, str.strip ])\n\n# Pass closures as pipes.\npipeline.through([ str.title, lambda passable, next: next_pipe(passable.strip)])\n\n# Pass objects as pipes.\npipeline.through([ TitlePipe(), StripPipe() ])\n```\n\n### `via()`\n\nThis method is used to set the method to call on all the pipes in the pipeline.\n\n```python\ndef via( method: str ): Pipeline\n```\n\n#### Examples\n```python\n# Set the method used in all classes in the pipeline to process the data as `execute()`.\npipeline.via( 'execute' )\n\n# Set the method used in all classes in the pipeline to process the data as `borkborkbork()`.\npipeline.via( 'borkborkbork' )\n```\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2024 Matthew Batchelder Permission 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. ",
"summary": "A library that implements the Chain of Responsibility pattern.",
"version": "1.0.1",
"project_urls": {
"Homepage": "https://github.com/borkweb/python-pipelinechain"
},
"split_keywords": [
"pipeline",
" library"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "6b7544395d74079221292048d8f35986f6cb057398952e2a698b47be5a2c6884",
"md5": "8134c38057a115ef3447ec292d82c267",
"sha256": "aa9f143cad7ef7de180f96aa0a07400b7cfefc7678e04f2731241298e6bad266"
},
"downloads": -1,
"filename": "pipelinechain-1.0.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "8134c38057a115ef3447ec292d82c267",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 7941,
"upload_time": "2024-04-27T13:01:44",
"upload_time_iso_8601": "2024-04-27T13:01:44.988609Z",
"url": "https://files.pythonhosted.org/packages/6b/75/44395d74079221292048d8f35986f6cb057398952e2a698b47be5a2c6884/pipelinechain-1.0.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d00cfe6213884492ed11ca73f70304230a69b306687c35860dd21f817ea6f087",
"md5": "fe9e71ead85a8c791e10a4837266c2e9",
"sha256": "2128926dc236476e6ce32f4e3f0aded1799590883f9c6d7cd6962d2541c5ca4d"
},
"downloads": -1,
"filename": "pipelinechain-1.0.1.tar.gz",
"has_sig": false,
"md5_digest": "fe9e71ead85a8c791e10a4837266c2e9",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 7904,
"upload_time": "2024-04-27T13:01:46",
"upload_time_iso_8601": "2024-04-27T13:01:46.579464Z",
"url": "https://files.pythonhosted.org/packages/d0/0c/fe6213884492ed11ca73f70304230a69b306687c35860dd21f817ea6f087/pipelinechain-1.0.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-27 13:01:46",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "borkweb",
"github_project": "python-pipelinechain",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "pipelinechain"
}
