# packages

pkgId: 50265d4cae0fac43f30cc2eccf84e6930b4a79ab03f9d8d51b2500a41db2cf49
name: python-conkeyscan
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A Pentesters Confluence Keyword Scanner
url: https://github.com/CompassSecurity/conkeyscan
rpm_license: mit
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conkeyscan-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img width="150" src="https://github.com/CompassSecurity/conkeyscan/blob/main/logo.svg" alt="Conkeyscan logo">
  </p>


  [![PyPI version](https://badge.fury.io/py/conkeyscan.svg)](https://badge.fury.io/py/conkeyscan)

  > A Pentesters Confluence Keyword Scanner

  Using the Confluence API search functionality and CQL queries to search for keywords.



  1. Install from PyPI `pip install conkeyscan`
  2. Create a custom dictionary with search terms per line (recommended but optional).
  3. And then run it
  ```bash
  conkeyscan -url 'https://example.atlassian.net'  --username 'ex@amp.le' --password 'ATAT...' -p 'socks5://127.0.0.1:1337' -d ./dict.txt
  ```
  4. Ask for further help `conkeyscan -h`



  1. Install dependencies `pip install -r requirements.txt`

  2. Update the `src/conkeyscan/config/dict.txt` file, containing keywords you want to search for. One per line.

  3. run it `python3 -m conkeyscan.conkeyscan --url http://192.168.1.2:8090/ --username someUsr --password somePassOrAPIkey`



  > It is possible to use a password or an API key.

  To create an API key in the cloud go to: https://id.atlassian.com/manage-profile/security/api-tokens.

  If testing against OnPrem instance you can create an API key in the user settings (and use conkeyscan with the parameter `-on-prem-pat` or `-t` for certain versions).



  The default `dict.txt` file was taken from from [Conf-Thief](https://raw.githubusercontent.com/antman1p/Conf-Thief/master/dictionaries/secrets-keywords.txt).



  * Search for provided keywords
  * Handle rate limiting by itself, as long as the returned status code equals `HTTP 429`, or specify max requests per second in CLI
  * The user agent is randomized
  * Proxying is supported either via HTTP or socks. See cli help for examples
  * Custom CQL
  * SSL/TLS checks are disabled by default
  * Supports cloud- and datacenter/server editions



  * https://spark1.us/n0s1 actually great, supports Jira and others as well, has some drawbacks in on-prem engagements e.g disable TLS verification, missing Proxying, rate-limiting adaption?. Scans everything, nice for CI.
  * https://github.com/BluBracket/confluence-risk-scanner
  * https://github.com/antman1p/Conf-Thief


pkgId: e47a29070db98fbd22e238550ee871d6d4e87c0f8b40c2d5077065ffc9ed5f90
name: python-conllu
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary
url: https://github.com/EmilStenstrom/conllu/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conllu-5.0.1-1.src.rpm
checksum_type: sha256
description:
  **CoNLL-U Parser** parses a [CoNLL-U formatted](http://universaldependencies.org/format.html) string into a nested python dictionary. CoNLL-U is often the output of natural language processing tasks.



  - It's simple. ~300 lines of code.
  - It has no dependencies
  - Full typing support so your editor can do autocompletion
  - Nice set of tests with CI setup: [![Build](https://github.com/EmilStenstrom/conllu/workflows/Run%20tests%20for%20all%20supported%20python%20versions/badge.svg)](https://github.com/EmilStenstrom/conllu/actions?query=workflow%3A%22Run+tests+for+all+supported+python+versions%22)
  - It has 100% test branch coverage (and has undergone [mutation testing](https://github.com/boxed/mutmut/))
  - It has [![lots of downloads](http://pepy.tech/badge/conllu)](http://pepy.tech/project/conllu)



  Note: As of conllu 5.0, Python 3.8 is required to install conllu. See [Notes on updating from 4.0 to 5.0](#notes-on-updating-from-40-to-50)

  ```bash
  pip install conllu
  ```

  Or, if you are using [conda](https://conda.io/docs/):

  ```bash
  conda install -c conda-forge conllu
  ```



  Conllu version 5.0 drops support for Python 3.6 and 3.7 and requires Python 3.8 at a minimum. If you need support for older versions of python, you can always pin your install to an old version of conllu. You can install it with `pip install conllu==4.5.3`.



  Conllu version 4.0 drops support for Python 2 and all versions of earlier than Python 3.6. If you need support for older versions of python, you can always pin your install to an old version of conllu. You can install it with `pip install conllu==3.1.1`.



  The Universal dependencies 2.0 release changed two of the field names from xpostag -> xpos and upostag -> upos. Version 3.0 of conllu handles this by aliasing the previous names to the new names. This means you can use xpos/upos or xpostag/upostag, they will both return the same thing. This does change the public API slightly, so I've upped the major version to 3.0, but I've taken care to ensure you most likely DO NOT have to update your code when you update to 3.0.



  I don't like breaking backwards compatibility, but to be able to add new features I felt I had to. This means that updating from 0.1 to 1.0 *might* require code changes. Here's a guide on [how to upgrade to 1.0
  ](https://github.com/EmilStenstrom/conllu/wiki/Migrating-from-0.1-to-1.0).



  At the top level, conllu provides two methods, `parse` and `parse_tree`. The first one parses sentences and returns a flat list. The other returns a nested tree structure. Let's go through them one by one.



  ```python
  >>> from conllu import parse
  >>>
  >>> data = """
  ... # text = The quick brown fox jumps over the lazy dog.
  ... 1   The     the    DET    DT   Definite=Def|PronType=Art   4   det     _   _
  ... 2   quick   quick  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ... 3   brown   brown  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ... 4   fox     fox    NOUN   NN   Number=Sing                 5   nsubj   _   _
  ... 5   jumps   jump   VERB   VBZ  Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin   0   root    _   _
  ... 6   over    over   ADP    IN   _                           9   case    _   _
  ... 7   the     the    DET    DT   Definite=Def|PronType=Art   9   det     _   _
  ... 8   lazy    lazy   ADJ    JJ   Degree=Pos                  9   amod    _   _
  ... 9   dog     dog    NOUN   NN   Number=Sing                 5   nmod    _   SpaceAfter=No
  ... 10  .       .      PUNCT  .    _                           5   punct   _   _
  ...
  ... """
  ```

  Now you have the data in a variable called `data`. Let's parse it:

  ```python
  >>> sentences = parse(data)
  >>> sentences
  [TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>]
  ```

  <blockquote>

  **Advanced usage**: If you have many sentences (say over a megabyte) to parse at once, you can avoid loading them into memory at once by using `parse_incr()` instead of `parse`. It takes an opened file, and returns a generator instead of the list directly, so you need to either iterate over it, or call list() to get the TokenLists out. Here's how you would use it:

  ```python
  from io import open
  from conllu import parse_incr

  data_file = open("huge_file.conllu", "r", encoding="utf-8")
  for tokenlist in parse_incr(data_file):
      print(tokenlist)
  ```

  For most files, `parse` works fine.
  </blockquote>

  Since one CoNLL-U file usually contains multiple sentences, `parse()` always returns a list of sentences. Each sentence is represented by a TokenList.

  ```python
  >>> sentence = sentences[0]
  >>> sentence
  TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>
  ```

  The TokenList supports indexing, so you can get the first token, represented by an ordered dictionary, like this:

  ```python
  >>> token = sentence[0]
  >>> token
  {'id': 1,
       'form': 'The',
       'lemma': 'the',
       ...}
  >>> token["form"]
  'The'
  ```



  ```python
  >>> sentence = sentences[0]
  >>> sentence
  TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>
  >>> sentence.filter(form="quick")
  TokenList<quick>
  ```

  By using `filter(field1__field2=value)` you can filter based on subelements further down in a parsed token.

  ```python
  >>> sentence.filter(feats__Degree="Pos")
  TokenList<quick, brown, lazy>
  ```

  Filters can also be chained (meaning you can do `sentence.filter(...).filter(...)`), and filtering on multiple properties at the same time (`sentence.filter(field1=value1, field2=value2)`) means that ALL properties must match.



  You can also filter using a lambda function as value. This is useful if you, for instance, would like to filter out only tokens with integer ID:s:

  ```python
  >>> from conllu.models import TokenList, Token
  >>> sentence2 = TokenList([
  ...    Token(id=(1, "-", 2), form="It's"),
  ...    Token(id=1, form="It"),
  ...    Token(id=2, form="is"),
  ... ])
  >>> sentence2
  TokenList<It's, It, is>
  >>> sentence2.filter(id=lambda x: type(x) is int)
  TokenList<It, is>
  ```



  If you want to change your CoNLL-U file, there are a couple of convenience methods to know about.

  You can add a new token by simply appending a dictionary with the fields you want to a TokenList:

  ```python
  >>> sentence3 = TokenList([
  ...    {"id": 1, "form": "Lazy"},
  ...    {"id": 2, "form": "fox"},
  ... ])
  >>> sentence3
  TokenList<Lazy, fox>
  >>> sentence3.append({"id": 3, "form": "box"})
  >>> sentence3
  TokenList<Lazy, fox, box>
  ```

  Changing a sentence just means indexing into it, and setting a value to what you want:

  ```python
  >>> sentence4 = TokenList([
  ...    {"id": 1, "form": "Lazy"},
  ...    {"id": 2, "form": "fox"},
  ... ])
  >>> sentence4[1]["form"] = "crocodile"
  >>> sentence4
  TokenList<Lazy, crocodile>
  >>> sentence4[1] = {"id": 2, "form": "elephant"}
  >>> sentence4
  TokenList<Lazy, elephant>
  ```

  If you omit a field when passing in a dict, conllu will fill in a "_" for those values.

  ```python
  >>> sentences = parse("1  The")
  >>> sentences[0].append({"id": 2})
  >>> sentences[0]
  TokenList<The, _>
  ```



  Each sentence can also have metadata in the form of comments before the sentence starts. This is available in a property on the TokenList called `metadata`.

  ```python
  >>> sentence.metadata
  {'text': 'The quick brown fox jumps over the lazy dog.'}
  ```



  If you ever want to get your CoNLL-U formated text back (maybe after changing something?), use the `serialize()` method:

  ```python
  >>> print(sentence.serialize())

  1   The     the     DET    DT   Definite=Def|PronType=Art   4   det    _   _
  2   quick   quick   ADJ    JJ   Degree=Pos                  4   amod   _   _
  3   brown   brown   ADJ    JJ   Degree=Pos                  4   amod   _   _
  4   fox     fox     NOUN   NN   Number=Sing                 5   nsubj  _   _
  5   jumps   jump    VERB   VBZ  Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin   0   root   _   _
  6   over    over    ADP    IN   _                           9   case   _   _
  7   the     the     DET    DT   Definite=Def|PronType=Art   9   det    _   _
  8   lazy    lazy    ADJ    JJ   Degree=Pos                  9   amod   _   _
  9   dog     dog     NOUN   NN   Number=Sing                 5   nmod   _   SpaceAfter=No
  10  .       .       PUNCT  .    _                           5   punct  _   _
  ```



  You can also convert a TokenList to a TokenTree by using `to_tree`:

  ```python
  >>> sentence.to_tree()
  TokenTree<token={id=5, form=jumps}, children=[...]>
  ```

  That's it!



  Sometimes you're interested in the tree structure that hides in the `head` column of a CoNLL-U file. When this is the case, use `parse_tree` to get a nested structure representing the sentence.

  ```python
  >>> from conllu import parse_tree
  >>> sentences = parse_tree(data)
  >>> sentences
  [TokenTree<...>]
  ```

  <blockquote>

  **Advanced usage**: If you have many sentences (say over a megabyte) to parse at once, you can avoid loading them into memory at once by using `parse_tree_incr()` instead of `parse_tree`. It takes an opened file, and returns a generator instead of the list directly, so you need to either iterate over it, or call list() to get the TokenTrees out. Here's how you would use it:

  ```python
  from io import open
  from conllu import parse_tree_incr

  data_file = open("huge_file.conllu", "r", encoding="utf-8")
  for tokentree in parse_tree_incr(data_file):
      print(tokentree)
  ```

  </blockquote>

  Since one CoNLL-U file usually contains multiple sentences, `parse_tree()` always returns a list of sentences. Each sentence is represented by a TokenTree.

  ```python
  >>> root = sentences[0]
  >>> root
  TokenTree<token={id=5, form=jumps}, children=[...]>
  ```

  To quickly visualize the tree structure you can call `print_tree` on a TokenTree.

  ```python
  >>> root.print_tree()
  (deprel:root) form:jumps lemma:jump upos:VERB [5]
      (deprel:nsubj) form:fox lemma:fox upos:NOUN [4]
          (deprel:det) form:The lemma:the upos:DET [1]
          (deprel:amod) form:quick lemma:quick upos:ADJ [2]
          (deprel:amod) form:brown lemma:brown upos:ADJ [3]
      (deprel:nmod) form:dog lemma:dog upos:NOUN [9]
          (deprel:case) form:over lemma:over upos:ADP [6]
          (deprel:det) form:the lemma:the upos:DET [7]
          (deprel:amod) form:lazy lemma:lazy upos:ADJ [8]
      (deprel:punct) form:. lemma:. upos:PUNCT [10]
  ```

  To access the token corresponding to the current node in the tree, use `token`:

  ```python
  >>> root.token
  {
      'id': 5,
      'form': 'jumps',
      'lemma': 'jump',
      ...
  }
  ```

  To start walking down the children of the current node, use the children attribute:

  ```python
  >>> children = root.children
  >>> children
  [
      TokenTree<token={id=4, form=fox}, children=[...]>,
      TokenTree<token={id=9, form=dog}, children=[...]>,
      TokenTree<token={id=10, form=.}, children=None>
  ]
  ```

  Just like with `parse()`, if a sentence has metadata it is available in a property on the TokenTree root called `metadata`.

  ```python
  >>> root.metadata
  {'text': 'The quick brown fox jumps over the lazy dog.'}
  ```

  If you ever want to get your CoNLL-U formated text back (maybe after changing something?), use the `serialize()` method:

  ```python
  >>> print(root.serialize())

  1   The     the    DET    DT   Definite=Def|PronType=Art   4   det     _   _
  2   quick   quick  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ...
  ```

  If you want to write it back to a file, you can use something like this:

  ```python
  >>> from conllu import parse_tree
  >>> sentences = parse_tree(data)
  >>>
  >>> # Make some change to sentences here
  >>>
  >>> with open('file-to-write-to', 'w') as f:
  ...     f.writelines([sentence.serialize() + "\n" for sentence in sentences])
  ```



  Far from all CoNLL-U files found in the wild follow the CoNLL-U format specification. CoNLL-U tries to parse even files that are malformed according to the specification, but sometimes that doesn't work. For those situations you can change how conllu parses your files.

  A normal CoNLL-U file consists of a specific set of fields (id, form, lemma, and so on...). Let's walk through how to parse a custom format using the three options `fields`, `field_parsers`, `metadata_parsers`. Here's the custom format we'll use.

  ```python
  >>> data = """
  ... # tagset = TAG1|TAG2|TAG3|TAG4
  ... # sentence-123
  ... 1   My       TAG1|TAG2
  ... 2   custom   TAG3
  ... 3   format   TAG4
  ...
  ... """
  ```

  Now, let's parse this with the the default settings, and look specifically at the first token to see how it was parsed.

  ```python
  >>> sentences = parse(data)
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'lemma': 'TAG1|TAG2'}
  ```

  The parser has assumed (incorrectly) that the third field must the the default ´lemma´ field and parsed it as such. Let's customize this so the parser gets the name right, by setting the `fields` parameter when calling parse.

  ```python
  >>> sentences = parse(data, fields=["id", "form", "tag"])
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'tag': 'TAG1|TAG2'}
  ```

  The only difference is that you now get the correct field name back when parsing. Now let's say you want those two tags returned as a list instead of as a string. This can be done using the `field_parsers` argument.

  ```python
  >>> split_func = lambda line, i: line[i].split("|")
  >>> sentences = parse(data, fields=["id", "form", "tag"], field_parsers={"tag": split_func})
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'tag': ['TAG1', 'TAG2']}
  ```

  That's much better! `field_parsers` specifies a mapping from a field name, to a function that can parse that field. In our case, we specify that the field with custom logic is `"tag"` and that the function to handle it is `split_func`. Each field_parser gets sent two parameters:

  * `line`: The whole list of values from this line, split on whitespace. The reason you get the full line is so you can merge several tokens into one using a field_parser if you want.
  * `i`: The current location in the line where you currently are. Most often, you'll use `line[i]` to get the current value.

  In our case, we return `line[i].split("|")`, which returns a list like we want.

  Let's look at the metadata in this example.

  ```text


  ```

  None of these values are valid in CoNLL-U, but since the first line follows the key-value format of other (valid) fields, conllu will parse it anyway:

  ```python
  >>> sentences = parse(data)
  >>> sentences[0].metadata
  {'tagset': 'TAG1|TAG2|TAG3|TAG4'}
  ```

  Let's return this as a list using the `metadata_parsers` parameter.

  ```python
  >>> sentences = parse(data, metadata_parsers={"tagset": lambda key, value: (key, value.split("|"))})
  >>> sentences[0].metadata
  {'tagset': ['TAG1', 'TAG2', 'TAG3', 'TAG4']}
  ```

  A metadata parser behaves similarily to a field parser, but since most comments you'll see will be of the form "key = value" these values will be parsed and cleaned first, and then sent to your custom metadata_parser. Here we just take the value, and split it on "|", and return a list back. And lo and behold, we get what we wanted!

  Now, let's deal with the "sentence-123" comment. Specifying another metadata_parser won't work, because this is an ID that will be different for each sentence. Instead, let's use a special metadata parser, called `__fallback__`.

  ```python
  >>> sentences = parse(data, metadata_parsers={
  ...    "tagset": lambda key, value: (key, value.split("|")),
  ...    "__fallback__": lambda key, value: ("sentence-id", key)
  ... })
  >>> sentences[0].metadata
  {
      'tagset': ['TAG1', 'TAG2', 'TAG3', 'TAG4'],
      'sentence-id': 'sentence-123'
  }
  ```

  Just what we wanted! `__fallback__` gets called any time none of the other metadata_parsers match, and just like the others, it gets sent the key and value of the current line. In our case, the line contains no "=" to split on, so key will be "sentence-123" and value will be empty. We can return whatever we want here, but let's just say we want to call this field "sentence-id" so we return that as the key, and "sentence-123" as our value.

  Finally, consider an even trickier case.

  ```python
  >>> data = """
  ... # id=1-document_id=36:1047-span=1
  ... 1   My       TAG1|TAG2
  ... 2   custom   TAG3
  ... 3   format   TAG4
  ...
  ... """
  ```

  This is actually three different comments, but somehow they are separated by "-" instead of on their own lines. To handle this, we get to use the ability of a metadata_parser to return multiple matches from a single line.

  ```python
  >>> sentences = parse(data, metadata_parsers={
  ...    "__fallback__": lambda key, value: [pair.split("=") for pair in (key + "=" + value).split("-")]
  ... })
  >>> sentences[0].metadata
  {
      'id': '1',
      'document_id': '36:1047',
      'span': '1'
  }
  ```

  Our fallback parser returns a **list** of matches, one per pair of metadata comments we find. The `key + "=" + value` trick is needed since by default conllu assumes that this is a valid comment, so `key` is "id" and `value` is everything after the first "=", `1-document_id=36:1047-span=1` (note the missing "id=" in the beginning). We need to add it back before splitting on "-".

  And that's it! Using these tricks you should be able to parse all the strange files you stumble into.



  1. Make a fork of the repository to your own GitHub account.

  2. Clone the repository locally on your computer:
      ```bash
      git clone git@github.com:YOURUSERNAME/conllu.git conllu
      cd conllu
      ```

  3. Install the library used for running the tests:
      ```bash
      pip install tox
      ```

  4. Now you can run the tests:
      ```bash
      tox
      ```
      This runs tox across all supported versions of Python, and also runs checks for code-coverage, syntax errors, and how imports are sorted.

  4. (Alternative) If you just have one version of python installed, and don't want to go through the hassle of installing multiple version of python (hint: Install pyenv and pyenv-tox), **it's fine to run tox with just one version of python**:

      ```bash
      tox -e py38
      ```

  5. Make a pull request. Here's a [good guide on PRs from GitHub](https://help.github.com/articles/creating-a-pull-request-from-a-fork/).

  Thanks for helping conllu become a better library!

rpm_license:
  The MIT License (MIT)  Copyright (c) 2016 Emil Stenström  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.


pkgId: cb7b6d143a83112e429069634ddc369d1bfdaae1dacb7901f520bb2d06016e07
name: python-conn-check
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Utility for verifying connectivity between services
url: http://conn-check.org/
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conn-check-1.5.0-1.src.rpm
checksum_type: sha256
description:
  conn-check allows for checking connectivity with external services.
  You can write a config file that defines services that you need to
  have access to, and conn-check will check connectivity with each.
  It supports various types of services, all of which allow for
  basic network checks, but some allow for confirming credentials
  work also.


pkgId: ef4652901c917664292945267a93b309b99a95bc2fe2f3e37c68dfbd7608b594
name: python-connecpy
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Code generator, server library and client library for the Connect Protocol
url: https://pypi.org/project/connecpy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connecpy-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Python implementation of [Connect Protocol](https://connectrpc.com/docs/protocol).

  This repo contains a protoc plugin that generates sever and client code and a pypi package with common implementation details.



  You can install the protoc plugin to generate files by running the command:

  ```sh
  go install github.com/i2y/connecpy/protoc-gen-connecpy@latest
  ```

  Additionally, please add the connecpy package to your project using your preferred package manager. For instance, with [Rye](https://rye-up.com/), use the command:

  ```sh
  rye add connecpy
  ```

  To run the server, you'll need one of the following: [Uvicorn](https://www.uvicorn.org/), [Daphne](https://github.com/django/daphne), or [Hypercorn](https://gitlab.com/pgjones/hypercorn). If your goal is to support both HTTP/1.1 and HTTP/2, you should opt for either Daphne or Hypercorn. Additionally, to test the server, you might need a client command, such as [buf](https://buf.build/docs/installation).




  Use the protoc plugin to generate connecpy server and client code.

  ```sh
  protoc --python_out=./ --pyi_out=./ --connecpy_out=./ ./haberdasher.proto
  ```



  ```python

  import random

  from connecpy.exceptions import InvalidArgument
  from connecpy.context import ServiceContext

  from haberdasher_pb2 import Hat, Size


  class HaberdasherService(object):
      async def MakeHat(self, req: Size, ctx: ServiceContext) -> Hat:
          print("remaining_time: ", ctx.time_remaining())
          if req.inches <= 0:
              raise InvalidArgument(
                  argument="inches", error="I can't make a hat that small!"
              )
          response = Hat(
              size=req.inches,
              color=random.choice(["white", "black", "brown", "red", "blue"]),
          )
          if random.random() > 0.5:
              response.name = random.choice(
                  ["bowler", "baseball cap", "top hat", "derby"]
              )

          return response
  ```

  ```python

  from connecpy import context
  from connecpy.asgi import ConnecpyASGIApp

  import haberdasher_connecpy
  from service import HaberdasherService

  service = haberdasher_connecpy.HaberdasherServer(
      service=HaberdasherService()
  )
  app = ConnecpyASGIApp()
  app.add_service(service)
  ```

  Run the server with
  ```sh
  uvicorn --port=3000 server:app
  ```
  or

  ```sh
  daphne --port=3000 server:app
  ```

  or

  ```sh
  hypercorn --bind :3000 server:app
  ```



  ```python

  import asyncio

  import httpx

  from connecpy.context import ClientContext
  from connecpy.exceptions import ConnecpyServerException

  import haberdasher_connecpy, haberdasher_pb2


  server_url = "http://localhost:3000"
  timeout_s = 5


  async def main():
      session = httpx.AsyncClient(
          base_url=server_url,
          timeout=timeout_s,
      )
      client = haberdasher_connecpy.AsyncHaberdasherClient(server_url, session=session)

      try:
          response = await client.MakeHat(
              ctx=ClientContext(),
              request=haberdasher_pb2.Size(inches=12),
              
              
          )
          if not response.HasField("name"):
              print("We didn't get a name!")
          print(response)
      except ConnecpyServerException as e:
          print(e.code, e.message, e.to_dict())
      finally:
          
          await session.aclose()


  if __name__ == "__main__":
      asyncio.run(main())
  ```

  Example output :
  ```
  size: 12
  color: "black"
  name: "bowler"
  ```



  ```python

  from connecpy.context import ClientContext
  from connecpy.exceptions import ConnecpyServerException

  import haberdasher_connecpy, haberdasher_pb2


  server_url = "http://localhost:3000"
  timeout_s = 5


  def main():
      client = haberdasher_connecpy.HaberdasherClient(server_url, timeout=timeout_s)

      try:
          response = client.MakeHat(
              ctx=ClientContext(),
              request=haberdasher_pb2.Size(inches=12),
          )
          if not response.HasField("name"):
              print("We didn't get a name!")
          print(response)
      except ConnecpyServerException as e:
          print(e.code, e.message, e.to_dict())


  if __name__ == "__main__":
      main()
  ```



  Of course, you can use any HTTP client to make requests to a Connecpy server. For example, commands like `curl` or `buf curl` can be used, as well as HTTP client libraries such as `requests`, `httpx`, `aiohttp`, and others. The examples below use `curl` and `buf curl`.

  Content-Type: application/proto, HTTP/1.1
  ```sh
  buf curl --data '{"inches": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat --schema ./haberdasher.proto
  ```

  On Windows, Content-Type: application/proto, HTTP/1.1
  ```sh
  buf curl --data '{\"inches\": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat --schema .\haberdasher.proto
  ```

  Content-Type: application/proto, HTTP/2
  ```sh
  buf curl --data '{"inches": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat --http2-prior-knowledge --schema ./haberdasher.proto
  ```

  On Windows, Content-Type: application/proto, HTTP/2
  ```sh
  buf curl --data '{\"inches\": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat --http2-prior-knowledge --schema .\haberdasher.proto
  ```


  Content-Type: application/json, HTTP/1.1
  ```sh
  curl -X POST -H "Content-Type: application/json" -d '{"inches": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat
  ```

  On Windows, Content-Type: application/json, HTTP/1.1
  ```sh
  curl -X POST -H "Content-Type: application/json" -d '{\"inches\": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat
  ```

  Content-Type: application/json, HTTP/2
  ```sh
  curl --http2-prior-knowledge -X POST -H "Content-Type: application/json" -d '{"inches": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat
  ```

  On Windows, Content-Type: application/json, HTTP/2
  ```sh
  curl --http2-prior-knowledge -X POST -H "Content-Type: application/json" -d '{\"inches\": 12}' -v http://localhost:3000/i2y.connecpy.example.Haberdasher/MakeHat
  ```




  Connecpy protoc plugin generates the code based on [Connect Protocl](https://connectrpc.com/docs/protocol) from the `.proto` files.
  Currently, Connecpy supports only Unary RPCs using the POST HTTP method. Connecpy will support other types of RPCs as well, in the near future.





  You can set server path prefix by passing `server_path_prefix` to `ConnecpyASGIApp` constructor.

  This example sets server path prefix to `/foo/bar`.
  ```python

  service = haberdasher_connecpy.HaberdasherServer(
      service=HaberdasherService(),
      server_path_prefix="/foo/bar",
  )
  ```

  ```python

  response = await client.MakeHat(
      ctx=ClientContext(),
      request=haberdasher_pb2.Size(inches=12),
      server_path_prefix="/foo/bar",
  )
  ```



  ConnecpyASGIApp supports interceptors. You can add interceptors by passing `interceptors` to `ConnecpyASGIApp` constructor.
  AsyncConnecpyServerInterceptor

  ```python

  from typing import Any, Callable

  from connecpy import context
  from connecpy.asgi import ConnecpyASGIApp
  from connecpy.interceptor import AsyncConnecpyServerInterceptor

  import haberdasher_connecpy
  from service import HaberdasherService


  class MyInterceptor(AsyncConnecpyServerInterceptor):
      def __init__(self, msg):
          self._msg = msg

      async def intercept(
          self,
          method: Callable,
          request: Any,
          ctx: context.ServiceContext,
          method_name: str,
      ) -> Any:
          print("intercepting " + method_name + " with " + self._msg)
          return await method(request, ctx)


  my_interceptor_a = MyInterceptor("A")
  my_interceptor_b = MyInterceptor("B")

  service = haberdasher_connecpy.HaberdasherServer(service=HaberdasherService())
  app = ConnecpyASGIApp(
      interceptors=(my_interceptor_a, my_interceptor_b),
  )
  app.add_service(service)
  ```

  Btw, `ConnecpyServerInterceptor`'s `intercept` method has compatible signature as `intercept` method of [grpc_interceptor.server.AsyncServerInterceptor](https://grpc-interceptor.readthedocs.io/en/latest/#async-server-interceptors), so you might be able to convert Connecpy interceptors to gRPC interceptors by just changing the import statement and the parent class.




  You can also use any ASGI middlewares with ConnecpyASGIApp.
  The example bleow uses [brotli-asgi](https://github.com/fullonic/brotli-asgi).

  ```python

  from brotli_asgi import BrotliMiddleware
  from connecpy import context
  from connecpy.asgi import ConnecpyASGIApp

  import haberdasher_connecpy
  from service import HaberdasherService

  service = haberdasher_connecpy.HaberdasherServer(
      service=HaberdasherService()
  )
  app = ConnecpyASGIApp()
  app.add_service(service)

  app = BrotliMiddleware(app, minimum_size=1000)
  ```


  In Connecpy, unlike connect-go, it is not possible to simultaneously support both gRPC and Connect RPC on the same server and port. In addition to it, Connecpy itself doesn't support gRPC. However, implementing a gRPC server using the same service code used for Connecpy server is feasible, as shown below. This is possible because the type signature of the service class in Connecpy is compatible with type signature gRPC farmework requires.
  The example below uses [grpc.aio](https://grpc.github.io/grpc/python/grpc_asyncio.html) and there are in [example dicrectory](example/README.md).


  ```python

  import asyncio

  from grpc.aio import server

  import haberdasher_pb2_grpc


  from service import HaberdasherService

  host = "localhost:50051"


  async def main():
      s = server()
      haberdasher_pb2_grpc.add_HaberdasherServicer_to_server(HaberdasherService(), s)
      bound_port = s.add_insecure_port(host)
      print(f"localhost:{bound_port}")
      await s.start()
      await s.wait_for_termination()


  if __name__ == "__main__":
      asyncio.run(main())
  ```

  ```python

  import asyncio

  from grpc.aio import insecure_channel

  import haberdasher_pb2
  import haberdasher_pb2_grpc


  target = "localhost:50051"


  async def main():
      channel = insecure_channel(target)
      stub = haberdasher_pb2_grpc.HaberdasherStub(channel)
      request = haberdasher_pb2.Size(inches=12)
      response = await stub.MakeHat(request)
      print(response)


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  Currently, message body length limit is set to 100kb, you can override this by passing `max_receive_message_length` to `ConnecpyASGIApp` constructor.

  ```python

  app = ConnecpyASGIApp(max_receive_message_length=10)

  ```



  The initial version (1.0.0) of this software was created by modifying https://github.com/verloop/twirpy at January 4, 2024, so that it supports Connect Protocol. Therefore, this software is also licensed under Unlicense same as twirpy.


pkgId: 7228989fb905731ca6917084fe04f0a2eb57dffe4290ab1e676755714eecf118
name: python-connect-box
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Python client for interacting with Compal CH7465LG devices.
url: https://github.com/home-assistant-ecosystem/python-connect-box
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-box-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Python Client for interacting with the cable modem/router Compal CH7465LG which
  is provided under different names by various ISP in Europe.
  - UPC Connect Box (CH)
  - Play Connect Box (PL)
  - Irish Virgin Media Super Hub 3.0 (IE)
  - Ziggo Connectbox (NL)
  - Unitymedia Connect Box (DE)
  This module is not official, developed, supported or endorsed by UPC,
  Unitymedia or Compal.
  There is an interface with is providing details about various states like the
  DHCP lease table for Ethernet and Wifi.
      <?xml version="1.0" encoding="UTF-8"?>
      <LanUserTable>
         <Ethernet>
            <clientinfo>
               <interface>Ethernet 2</interface>
               <IPv4Addr>192.168.0.160/24</IPv4Addr>
               <index>0</index>
               <interfaceid>2</interfaceid>
               <hostname>GW-B072BF27A983</hostname>
               <MACAddr>B0:72:BF:27:A9:83</MACAddr>
               <method>1</method>
               <leaseTime>00:00:34:53</leaseTime>
  ``connect_box`` is handling the retrieval of the data and the parsing. The
  primary use case is the `Home Assistant <https://home-assistant.io>`_
  ``upc_connect`` device tracker but one could use it in other projects as well.


pkgId: 1d45d3f44833f4eebb80d8c4ce5caa0bc57b38c35281656eca7b2bc16c926c6b
name: python-connect-cli
arch: src
version: 31.0
epoch: 0
release: 1
summary: CloudBlue Connect Command Line Interface
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-cli-31.0-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-cli.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-cli.svg)](https://pypi.org/project/connect-cli/) ![PyPI - Downloads](https://img.shields.io/pypi/dm/connect-cli) ![Docker Pulls](https://img.shields.io/docker/pulls/cloudblueconnect/connect-cli) ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/cloudblue/connect-cli/build.yml?branch=master) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=connect-cli&metric=coverage)](https://sonarcloud.io/summary/new_code?id=connect-cli) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=connect-cli&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=connect-cli)



  The CloudBlue Connect Command Line Interface (CLI) is an extensible unified tool to perform various automation scenarios. With just one tool, you can control multiple Connect modules from the command line and automate them through scripts.

  Since it is extensible, users can write their own plugins to extend its functionalities.






  `connect-cli` depends on [Git](https://git-scm.com/), [Cairo](https://www.cairographics.org/),
  [Pango](https://pango.gnome.org/) and [GDK-PixBuf](https://developer.gnome.org/gdk-pixbuf/stable/).

  Please refers to the platform-specific instructions on how to install these dependecies:

  * [Linux](docs/linux_deps_install.md)
  * [Mac OS](docs/osx_deps_install.md)
  * [Windows](docs/win_deps_install.md)




  To use `connect-cli` you need a system with python 3.8 or later installed.

  ```sh
      $ pip install --upgrade connect-cli
  ```



  To use the Docker image of `connect-cli`:

  ```sh
      $ docker run -it -v $HOME/.ccli:/home/connect/.ccli cloudblueconnect/connect-cli ccli
  ```

  Please refer to the [`connect-cli` docker image documentation](https://hub.docker.com/r/cloudblueconnect/connect-cli) for more information.




  To install `connect-cli` with homebrew run:

  ```sh
      $ brew update
      $ brew tap cloudblue/connect
      $ brew install cloudblue/connect/connect-cli
  ```



  An installer package is available for Windows 10 or newer.
  You can download its zip file from the [Github Releases](https://github.com/cloudblue/connect-cli/releases) page.





  * [General](docs/core_usage.md)
  * [Locales](docs/locales_usage.md)
  * [Products](docs/products_usage.md)
  * [Customers](docs/customers_usage.md)
  * [Reports](docs/reports_usage.md)
  * [Translations](docs/translations_usage.md)
  * [Projects](docs/project_usage.md)
  * [Streams](docs/stream_usage.md)



  We use `isort` library to order and format our imports, and we check it using `flake8-isort` library (automatically on `flake8` run).
  For convenience you may run `poetry run isort .` to order imports.




  `connect-cli` uses [poetry](https://python-poetry.org/) for dependencies management and packaging.

  To run the `connect-cli` tests suite run:

  ```
  $ pip install poetry
  $ poetry install
  $ poetry run pytest
  ```




  `connect-cli` is released under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: 35be528ec2da0180bb3b0d882f09516263f723d76e4f0669112cf7b1352f9588
name: python-connect-eaas-core
arch: src
version: 33.0
epoch: 0
release: 1
summary: Connect Eaas Core
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-eaas-core-33.0-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-eaas-core.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-eaas-core.svg)](https://pypi.org/project/connect-eaas-core/) [![Build Status](https://github.com/cloudblue/connect-eaas-core/workflows/Build%20Connect%20EaaS%20Core/badge.svg)](https://github.com/cloudblue/connect-eaas-core/actions) [![Sonarcloud Status](https://sonarcloud.io/api/project_badges/measure?project=connect-eaas-core&metric=alert_status)](https://sonarcloud.io/dashboard?id=connect-eaas-core)
   [![SonarCloud Coverage](https://sonarcloud.io/api/project_badges/measure?project=connect-eaas-core&metric=coverage)](https://sonarcloud.io/component_measures/metric/coverage/list?id=connect-eaas-core)
   [![SonarCloud Bugs](https://sonarcloud.io/api/project_badges/measure?project=connect-eaas-core&metric=bugs)](https://sonarcloud.io/component_measures/metric/reliability_rating/list?id=connect-eaas-core)
   [![SonarCloud Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=connect-eaas-core&metric=vulnerabilities)](https://sonarcloud.io/component_measures/metric/security_rating/list?id=connect-eaas-core)






  `Connect EaaS Core` is a library that contains the base building blocks to develop extensions for the CloudBlue Connect platform.




  `Connect EaaS Core` requires python 3.9 or later.


  `Connect EaaS Core` can be installed from [pypi.org](https://pypi.org/project/connect-eaas-core/) using pip:

  ```
  $ pip install connect-eaas-core
  ```




  [`Connect EaaS Core` documentation](https://connect-eaas-core.readthedocs.io/en/latest/) is hosted on the _Read the Docs_ service.




  `Connect EaaS Core` is released under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: c3f1ac4a72da01b049ca61fea2029494a2e7f2e312df316adee138972ceff0a6
name: python-connect-extension-runner
arch: src
version: 33.2
epoch: 0
release: 1
summary: CloudBlue Connect EaaS Extension Runner
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-extension-runner-33.2-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-extension-runner.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-extension-runner.svg)](https://pypi.org/project/connect-extension-runner/) [![Build Connect Reports Core](https://github.com/cloudblue/connect-extension-runner/actions/workflows/build.yml/badge.svg)](https://github.com/cloudblue/connect-extension-runner/actions/workflows/build.yml) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=connect-extension-runner&metric=alert_status)](https://sonarcloud.io/dashboard?id=connect-extension-runner) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=connect-extension-runner&metric=coverage)](https://sonarcloud.io/dashboard?id=connect-extension-runner) [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=connect-extension-runner&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=connect-extension-runner)![Docker Image Version (latest semver)](https://img.shields.io/docker/v/cloudblueconnect/connect-extension-runner?label=docker%20version&sort=semver)![Docker Image Size (latest semver)](https://img.shields.io/docker/image-size/cloudblueconnect/connect-extension-runner?label=docker%20image%20size&sort=semver)![Docker Pulls](https://img.shields.io/docker/pulls/cloudblueconnect/connect-extension-runner)


pkgId: 7e14de7726bd04514e865f0a7799d3c70b441633fc4b7ddd6d91a42f62c760b8
name: python-connect-four-lib
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A library for connect 4 game
url: https://pypi.org/project/connect-four-lib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-four-lib-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/game-ai-platform-team/connect-four-lib/graph/badge.svg?token=MNLla272Cv)](https://codecov.io/gh/game-ai-platform-team/connect-four-lib)
  [![CI/CD](https://github.com/game-ai-platform-team/connect-four-lib/actions/workflows/cicd.yml/badge.svg)](https://github.com/game-ai-platform-team/connect-four-lib/actions/workflows/cicd.yml)

  A library for connect 4 game.



  - [Architecture](/docs/architecture.md)


pkgId: 0526f3b3f50e9de76bd9c7f5c1fd85473c29ebbc0714148723dce1fcaa28fe77
name: python-connect-markdown-renderer
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Connect Markdown Renderer
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-markdown-renderer-3.0.0-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-markdown-renderer.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-markdown-renderer.svg)](https://pypi.org/project/connect-markdown-renderer/) [![Build Status](https://github.com/cloudblue/connect-markdown-renderer/workflows/Build%20Connect%20Markdown%20Renderer/badge.svg)](https://github.com/cloudblue/connect-markdown-renderer/actions) [![codecov](https://codecov.io/gh/cloudblue/connect-markdown-renderer/branch/master/graph/badge.svg)](https://codecov.io/gh/cloudblue/connect-markdown-renderer) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=markdown-renderer&metric=alert_status)](https://sonarcloud.io/dashboard?id=markdown-renderer)




  `connect-markdown-renderer` is a small library that allow to render markdown documents in a terminal shell.




  `connect-markdown-renderer` can be installed from pypi.org with pip:

  ```sh

  $ pip install connect-markdown-renderer

  ```



  ```python

  from connect.utils.terminal.markdown import render

  my_md = """



  This is a paragraph with inline formatting like *italic*, **strong**, ~~strikethrough~~, `inline code` and :clapping_hands: emojis!.



  *Ordered list:*

  1. First item
  2. Second item
  3. Third item

  **Unordered list:**

  * First
  * Second
  * Third



  > This is a blockquote.
  > > ...and a nested blockquote.




  | Col 1 | Col 2 | Col 3 |
  |:------|:-----:|------:|
  | a | b | c |





  ```python

  def this_is_my_python_function(args):
      return 'Hello World!'


  """

  print(render(my_md))

  ```

  This code will produce the following output:

  ![Console markdown](screenshot_1.png)





  `connect-markdown-renderer` uses the new [markdown-it-py](https://github.com/executablebooks/markdown-it-py) parser and supports
  [CommonMark](https://commonmark.org) plus the following extensions:

  * tables
  * strikethrough
  * emoji

  `connect-markdown-renderer` uses [rich](https://github.com/Textualize/rich) to render the markdown in the terminal.




  `connect-markdown-renderer` is released under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: 5c51313bbc19fc6fcf22bc7bc3b6563d4491c530bad78fc4a23387186cd29447
name: python-connect-openapi-client
arch: src
version: 29.4
epoch: 0
release: 1
summary: Connect Python OpenAPI Client
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-openapi-client-29.4-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-openapi-client.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-openapi-client.svg)](https://pypi.org/project/connect-openapi-client/) [![Build Status](https://github.com/cloudblue/connect-python-openapi-client/workflows/Build%20Connect%20Python%20OpenAPI%20Client/badge.svg)](https://github.com/cloudblue/connect-python-openapi-client/actions) [![codecov](https://codecov.io/gh/cloudblue/connect-python-openapi-client/branch/master/graph/badge.svg)](https://codecov.io/gh/cloudblue/connect-python-openapi-client) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=connect-open-api-client&metric=alert_status)](https://sonarcloud.io/dashboard?id=connect-open-api-client)






  `Connect Python OpenAPI Client` is the simple, concise, powerful and REPL-friendly CloudBlue Connect API client.

  It has been designed following the [fluent interface design pattern](https://en.wikipedia.org/wiki/Fluent_interface).

  Due to its REPL-friendly nature, using the CloudBlue Connect OpenAPI specifications it allows developers to learn and
  play with the CloudBlue Connect API using a python REPL like [jupyter](https://jupyter.org/) or [ipython](https://ipython.org/).




  `Connect Python OpenAPI Client` requires python 3.9 or later.


  `Connect Python OpenAPI Client` can be installed from [pypi.org](https://pypi.org/project/connect-openapi-client/) using pip:

  ```
  $ pip install connect-openapi-client
  ```



  We use `isort` library to order and format our imports, and `black` - to format the code.
  We check it using `flake8-isort` and `flake8-black` libraries (automatically on `flake8` run).
  For convenience you may run `isort . && black .` to format the code.




  [`Connect Python OpenAPI Client` documentation](https://connect-openapi-client.readthedocs.io/en/latest/) is hosted on the _Read the Docs_ service.




  ``Connect Python OpenAPI Client`` is released under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: 832ae07dd4672dbac124cd8bb96e54e68e72ca3ff115c34ef3284da9dc9b1367
name: python-connect-reports-core
arch: src
version: 29.0
epoch: 0
release: 1
summary: Connect Reports Core
url: https://connect.cloudblue.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-reports-core-29.0-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-reports-core.svg) [![PyPi Status](https://img.shields.io/pypi/v/connect-reports-core.svg)](https://pypi.org/project/connect-reports-core/) [![Build Connect Reports Core](https://github.com/cloudblue/connect-reports-core/actions/workflows/build.yml/badge.svg)](https://github.com/cloudblue/connect-reports-core/actions/workflows/build.yml) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=connect-reports-core&metric=alert_status)](https://sonarcloud.io/dashboard?id=connect-reports-core) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=connect-reports-core&metric=coverage)](https://sonarcloud.io/dashboard?id=connect-reports-core) [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=connect-reports-core&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=connect-reports-core)



  `Connect Reports Core` is the kernel package for handling reports on CloudBlue Connect Ecosystem.
  This library is reponsible for validation of reports definition, choosing of renderer for parsing process and writing results of reports execution.




  `Connect Reports Core` requires python 3.8 or later and has the following dependencies:

  * openpyxl>=2.5.14
  * WeasyPrint>=53.4
  * Jinja2>=2.11.3
  * jsonschema<=3.2.0
  * pytz>=2021.1
  * lxml>=4.7.1

  `Connect Reports Core` can be installed from [pypi.org](https://pypi.org/project/connect-reports-core/) using pip:

  ```
  $ pip install connect-reports-core
  ```



  On MacOs:
  * Install system dependencies
  ```commandline
  brew install py3cairo pango
  ```
  * Create virtualenv
  * Install project dependencies
  ```commandline
  pip install poetry
  poetry update
  ```
  * Run tests
  ```commandline
  poetry run pytest
  ```




  ``Connect Reports Core`` is released under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: f0d88f1b11702399a13e87de6a97f782526cf75048727b824c41f055ad513a69
name: python-connect-sdk
arch: src
version: 22.0
epoch: 0
release: 1
summary: Connect Python SDK
url: https://github.com/ingrammicro/connect-python-sdk
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-sdk-22.0-1.src.rpm
checksum_type: sha256
description:
  ![pyversions](https://img.shields.io/pypi/pyversions/connect-sdk.svg)  [![PyPi Status](https://img.shields.io/pypi/v/connect-sdk.svg)](https://pypi.org/project/connect-sdk/) [![codecov](https://codecov.io/gh/cloudblue/connect-python-sdk/branch/master/graph/badge.svg)](https://codecov.io/gh/cloudblue/connect-python-sdk) [![Build Status](https://github.com/cloudblue/connect-python-sdk/workflows/Build%20Connect%20Python%20SDK/badge.svg)](https://github.com/cloudblue/connect-python-sdk/actions) [![PyPI status](https://img.shields.io/pypi/status/connect-sdk.svg)](https://pypi.python.org/pypi/connect-sdk/) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=connectpythonsdk&metric=alert_status)](https://sonarcloud.io/dashboard?id=connectpythonsdk)

  Connect Python SDK allows an easy and fast integration with Connect fulfillment API. Thanks to it you can automate the fulfillment of orders generated by your products.

  Please check the documentation available [here](https://connect-python-sdk.readthedocs.io), which contains information on how to install and use the library, and a complete API reference guide.



  This library may be consumed in your project in order to automate the fulfillment of requests, this class once imported into your project will allow you to:

  - Communicate with Connect using your API credentials.
  - List all requests, and even filter them:
    - For a specific product.
    - For a specific status.
    - For a specific asset.
    - Etc.
  - Process each request and obtain full details of the request.
  - Modify the activation parameters of each request in order to:
    - Inquiry for changes
    - Store information into the fulfillment request
  - Change the status of the requests from its initial pending state to either inquiring, failed or approved.
  - Generate and upload usage files to report usage for active contracts and listings.
  - Process usage file status changes.
  - Work with Notes for requests.
  - Generate logs.
  - Collect debug logs in case of failure.

  Your code may use any scheduler to execute, from a simple cron to a cloud scheduler like the ones available in Azure, Google, Amazon or other cloud platforms.



  ```sh
  $ pip install connect-sdk
  ```



  * Python 2.7+ or Python 3.4+
  * Requests (https://pypi.org/project/requests/)
  * Marshmallow (https://pypi.org/project/marshmallow/)



  If you want to contribute to the connect-python-sdk development feel free to open issues or fork the github repository and submit your pull request.





  Assuming that you have python and virtualenv installed, and forked the connect-python-sdk repository, set up your environment and install the required dependencies like this:

  ```sh
  $ git clone https://github.com/{your_github_account}/connect-python-sdk.git
  $ cd connect-python-sdk
  $ virtualenv venv
  $ . venv/bin/activate
  $ pip install -r requirements/test.txt
  ```



  The connect-python-sdk uses [pytest](https://docs.pytest.org/en/latest/) for unit testing.

  To run the entire tests suite execute:

  ```sh
  $ pytest
  ```



  The connect-python-sdk is released under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).


pkgId: 72c1dad7c11ebc5d3d99508035f14f0011449f26d8abecb6b45d5ed0a5f09e59
name: python-connect-sdk-haxe-port
arch: src
version: 22.2.0
epoch: 0
release: 1
summary: CloudBlue Connect SDK, generated from Haxe
url: https://github.com/cloudblue/connect-haxe-sdk
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-sdk-haxe-port-22.2.0-1.src.rpm
checksum_type: sha256
description:
  This is a Python 3 SDK for [CloudBlue Connect](https://www.cloudblue.com/connect/) platform, autogenerated from the Haxe source code available [here](https://github.com/cloudblue/connect-haxe-sdk).

  Documentation is available [here](https://cloudblue.github.io/connect-haxe-sdk/).

  > NOTE: This package is in development stage, please use the
  > [connect-sdk](https://pypi.org/project/connect-sdk/) package instead.


pkgId: 97ffd24c4414044d1f57a5851b070c11acd631fd38622f1eab29a790bc32ddd7
name: python-connect-sdk-python3
arch: src
version: 4.2.0
epoch: 0
release: 1
url: https://github.com/Worldline-Global-Collect/connect-sdk-python3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connect-sdk-python3-4.2.0-1.src.rpm
checksum_type: sha256
summary:
  SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API


pkgId: 762eb4c4d2e70ca026525779b633e3af8999123109dbfcfcbeafed2417e25de8
name: python-connectedcar
arch: src
version: 1.3.10
epoch: 0
release: 1
summary: ConnectedCar SDK
url: https://github.com/ianjwhite99/connected-car-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectedcar-1.3.10-1.src.rpm
checksum_type: sha256
description:
  ![ConnectedCar Python SDK Logo](https://user-images.githubusercontent.com/35158392/147300580-29723aab-ffae-46d3-ae60-72af59065daa.png)

  The ConnectedCar Python SDK is an open-source, python package that provides the ability to send commands to your Ford Sync Connect connected vehicle.



  ```sh
  python3 -m pip install connectedcar
  ```

  Requirements

  - To make requests to a vehicle, the end user must have signed up for an account using [Ford Pass](https://owner.ford.com/fordpass/fordpass-sync-connect.html). These credentials will be used to authenticate your requests.



  Import the ConnectedCar SDK

  ```python
  import connectedcar
  ```

  Create a new connectedcar `client`

  - Note the default ConnectedCar client_id is
    `9fb503e0-715b-47e8-adfd-ad4b7770f73b`

  ```python
  client = connectedcar.AuthClient('9fb503e0-715b-47e8-adfd-ad4b7770f73b', None, None, None, 'US') # Region argument is only required if you live outside the United States.
  ```

  - Note: If your region is outside of the US you can pass different region parameters. Regions: (US, CA, EU, AU)

  Use `client.get_user_access_token()` to exchange your user credentials for an **access object**. To make any vehicle data request to the Ford Sync Connect API, you'll need to give the SDK a valid **access token**.

  ```python
  access = client.get_user_access_token('<username>', '<password>')
  ```

  This access object will look like this:

  ```json
  {
    "access_token": "...",
    "token_type": "Bearer",
    "expiration": "2021-03-01T18:04:25+00:00",
    "refresh_token": "...",
    "refresh_expiration": "2021-03-02T18:03:25+00:00",
    "expires_in": "..."
  }
  ```

  Access tokens will expire every 2 hours, so you'll need to constantly refresh them by calling `client.exchange_refresh_token()`

  ```python
  refreshToken = client.exchange_refresh_token(access['refresh_token'])
  ```

  With your access token in hand, use `connectedcar.User()` to get a User object representing the user.

  ```python
  user = connectedcar.User(access['access_token'], "US") # Region argument is only required if you live outside the United States.
  ```

  Use `user.vehicles()` to return an array of all the vehicles associated with a users account. The response will include the **vehicle vin**.

  ```python
  vehicles = user.vehicles()

  vehicleList = [] # Array of vehicles

  for userVehicle in vehicles: # For each user vehicle
      vehicleList.append(userVehicle['VIN'])
  ```

  Now with a **vehicle vin** in hand, use `connectedcar.Vehicle()` to get a Vehicle object representing the user's vehicle.

  ```python
  currentVehicle = connectedcar.Vehicle(vehicleList[0], access['access_token'], "US") # Region argument is only required if you live outside the United States.
  ```

  Now you can ask the car to do things, or ask it for some data! For example:

  ```python
  currentVehicle.start()
  ```



  For more examples on what you can do with Sync Connected car, see the [examples](/examples) folder or take a peek at the [documentation](https://ianjwhite99.github.io/connected-car-python-sdk/).



  If you are interested in supporting the development of my projects check out my [patreon](https://www.patreon.com/ianjwhite99) or [buy me a coffee](https://www.buymeacoffee.com/ianjwhite9).



  THIS CODEBASE IS NOT ENDORSED, AFFILIATED, OR ASSOCIATED WITH FORD, FOMOCO OR THE FORD MOTOR COMPANY.


pkgId: 4e980e07b9d8dda573b686df1929b2380a16fa0da7bbef4204d1231894de5839
name: python-connection
arch: src
version: 2021.7.20
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/andrewp-as-is/connection.py
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connection-2021.7.20-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/badge/released-2021.7.20-green.svg?longCache=True)](https://pypi.org/project/connection/)
  [![](https://img.shields.io/badge/license-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ pip install connection
  ```


  ```python
  >>> import connection
  >>> connection.check()
  True
  ```

  timeout
  ```python
  >>> connection.check(timeout=2)
  ```

  url
  ```python
  >>> connection.check(url='https://github.com/')
  ```


pkgId: 3d092f5a8baa5f2f56f80f358b1de3d5b6225e4243f5bab836fc3765eebcdbc6
name: python-connection-restapi-client-poc
arch: src
version: 24.0.6.782
epoch: 0
release: 1
summary: Connection Rest API 1.0
url: https://pypi.org/project/connection-restapi-client-poc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connection-restapi-client-poc-24.0.6.782-1.src.rpm
checksum_type: sha256
description:
      No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)


pkgId: ffde47b47d565d3be5bf5b2af7fcbd1164a9546880aec125d02486d6ed73e318
name: python-connectionist
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Tools for classical connectionist models of reading with TensorFlow
url: https://github.com/jasonlo/connectionist
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectionist-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/connectionist.svg?style=flat&color=brightgreen)](https://pypi.org/project/connectionist/)
  [![License](https://img.shields.io/github/license/jasonlo/connectionist.svg?color=brightgreen)](https://github.com/JasonLo/connectionist/blob/main/LICENSE)
  [![Docs](https://img.shields.io/badge/docs-connectionist-4051b5)](https://jasonlo.github.io/connectionist/)

  **Connectionist** contains some tools for classical [connectionist models of reading](https://www.cnbc.cmu.edu/~plaut/papers/pdf/Plaut05chap.connModelsReading.pdf) in TensorFlow. This project is a course companion python library for [Contemporary neural networks for cognition and cognitive neuroscience](https://drive.google.com/drive/folders/1ZNmK-W8bk3iIH6M5cYzhO_XGhCrxFXzL).



  - Ready-to-use models of reading in TensorFlow
  - Various "brain" (model) damaging APIs
  - Basic building blocks (layers) for connectionist models



  - Python >=3.8
  - TensorFlow >=2.9



  ```bash
  pip install connectionist
  ```



  End-to-end toy example with Plaut, McClelland, Seidenberg and Patterson (1996), simulation 3 model:

  ```python
  import tensorflow as tf
  from connectionist.data import ToyOP
  from connectionist.models import PMSP

  data = ToyOP()
  model = PMSP(tau=0.2, h_units=10, p_units=9, c_units=5)
  model.compile(
      optimizer=tf.keras.optimizers.Adam(),
      loss=tf.keras.losses.BinaryCrossentropy(),
  )
  model.fit(data.x_train, data.y_train, epochs=3, batch_size=20)
  model(data.x_train)
  ```



  [https://jasonlo.github.io/connectionist/](https://jasonlo.github.io/connectionist/)


pkgId: 87ff06489169d68f4a941b99e8b5c77a446a15cdcbe4452faffc915199086e7d
name: python-connectionvault
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: help with connection details
url: https://pypi.org/project/connectionvault/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectionvault-0.0.1-1.src.rpm
checksum_type: sha256
description:
  cd /path/to/your/project


  python3 -m venv venv
  source venv/bin/activate  # For Linux/Mac



  pip install poetry


  poetry init


  poetry add requests


  poetry build


pkgId: 37623c8065d9db02ef00c82871e488d86744038e4efec212302c2d53f25fab45
name: python-connectionvault
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: help with connection details
url: https://pypi.org/project/connectionvault/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectionvault-0.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Upload Python Package](https://github.com/ankit48365/ConnectionVault/actions/workflows/python-publish.yml/badge.svg)](https://github.com/ankit48365/ConnectionVault/actions/workflows/python-publish.yml)
  ![Latest Release](https://img.shields.io/badge/release-v0.0.4-blue)





  The purpose of this project is to centralize the database connections file (as YAML) on a user's machine. The project has two utilities:

  1. **Connection Manager:** Allows you to choose and load a connection string in a Python code quickly.

     Python code usage example:

     ```python
     from app.src.connection_utility import load_connections, choose_connection
     from sqlalchemy import create_engine
     import pandas as pd

     def main():
         connections = load_connections()
         conn = choose_connection(connections)

         engine = create_engine(conn)
         query = input("Input your query: ")
         df = pd.read_sql_query(query, engine)
         print(df)

     if __name__ == "__main__":
         main()```
  2. **Connection Utility:** Allows you to save new connections, and add, update, delete, or see existing connections in the saved YAML file.



  To run this project, you need to define and save a path with the name `conn_home`. This is where you’ll save the `connections.yaml` file, which stores your database credentials.



  ```

  setx conn_home "C:\path\outside\your\project\preferably"


  echo %conn_home%


  setx conn_home "C:\path\outside\your\project\preferably"


  echo %conn_home%
  ```


  ```

  [System.Environment]::SetEnvironmentVariable('conn_home', 'C:\path\outside\your\project\preferably', 'User')


  $env:conn_home
  ```



  ```bash

  echo 'export conn_home="path/outside/your/project/preferably"' >> ~/.bashrc


  source ~/.bashrc
  ```


pkgId: ea24911bf5166055e1a8a2766963b4cbb5a7c7c0cbdf3ca1f2d779adf533c0b3
name: python-connectionvault
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: help with connection details
url: https://pypi.org/project/connectionvault/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectionvault-0.0.6-1.src.rpm
checksum_type: sha256
description:
  [![Upload Python Package](https://github.com/ankit48365/ConnectionVault/actions/workflows/python-publish.yml/badge.svg)](https://github.com/ankit48365/ConnectionVault/actions/workflows/python-publish.yml)
  ![Latest Release](https://img.shields.io/badge/release-v0.0.4-blue)






  The purpose of this project is to centralize the database connections file (as YAML) on a user's machine. The project has two utilities:

  1. **Connection Manager:** Allows you to choose and load a connection string in a Python code quickly.

     Python code usage example:

     ```python
     from app.src.connection_utility import load_connections, choose_connection
     from sqlalchemy import create_engine
     import pandas as pd

     def main():
         connections = load_connections()
         conn = choose_connection(connections)

         engine = create_engine(conn)
         query = input("Input your query: ")
         df = pd.read_sql_query(query, engine)
         print(df)

     if __name__ == "__main__":
         main()```
  2. **Connection Utility:** Allows you to save new connections, and add, update, delete, or see existing connections in the saved YAML file.



  To run this project, you need to define and save a path with the name `conn_home`. This is where you’ll save the `connections.yaml` file, which stores your database credentials.



  ```

  setx conn_home "C:\path\outside\your\project\preferably"


  echo %conn_home%


  setx conn_home "C:\path\outside\your\project\preferably"


  echo %conn_home%
  ```


  ```

  [System.Environment]::SetEnvironmentVariable('conn_home', 'C:\path\outside\your\project\preferably', 'User')


  $env:conn_home
  ```



  ```bash

  echo 'export conn_home="path/outside/your/project/preferably"' >> ~/.bashrc


  source ~/.bashrc
  ```


pkgId: d6035d3952bd94bac05c7596e525102e4861b66ff2d2a45811d50454551d49fa
name: python-connectlife
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A Python library for communicating with the ConnectLife API
url: https://github.com/oyvindwe/connectlife
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectlife-0.5.2-1.src.rpm
checksum_type: sha256
description:
  Used by devices from Hisense, Gorenje, ASKO & ATAG and ETNA Connect.

  The goal of this library is to support a native [Home Assistant](https://www.home-assistant.io/) integration for devices
  that uses the ConnectLife API.

  The code is based on [Connectlife API proxy / MQTT Home Assistant integration](https://github.com/bilan/connectlife-api-connector)
  ([MIT license](https://github.com/bilan/connectlife-api-connector/blob/51c6b8e4562205e1c343d0cba19354f411bd5e77/composer.json#L2-L6)).

  Software is provided as is - use at your own risk. There is probably no way to harm your physical devices, but
  there is no guarantee that you don't experience other problems, for instance locking your ConnectLife account.

  Licensed under [GPLv3](LICENSE).

  To test out the library:
  ```bash
  pip install connectlife
  python -m connectlife.dump --username <username> --password <password>
  ```

  This will log in to the ConnectLife API using the provided username and password, and print the list of all fields
  for all appliances that is registered with the account.

  The Home Assistant integration is currently in discovery phase. Please contribute your device dumps to help
  the development.


pkgId: 112cd03a1269156caab9175d9aeb809a8d51846d08a7e8714cb377a73a747f16
name: python-connectome
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A library for datasets containing heterogeneous data
url: https://github.com/neuro-ml/connectome
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectome-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![docs](https://img.shields.io/badge/-docs-success)](https://neuro-ml.github.io/connectome/)
  [![codecov](https://codecov.io/gh/neuro-ml/connectome/branch/master/graph/badge.svg)](https://codecov.io/gh/neuro-ml/connectome)
  [![pypi](https://img.shields.io/pypi/v/connectome?logo=pypi&label=PyPi)](https://pypi.org/project/connectome/)
  ![License](https://img.shields.io/github/license/neuro-ml/connectome)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/connectome)](https://pypi.org/project/connectome/)

  Connectome is a framework for datasets management with strong emphasis on simplicity, composability and reusability.



  * Self-consistency: connectome encourages data transformations that keep entries' fields consistent
  * Caching: transformations' caching works out of the box and supports both caching to RAM and to Disk
  * Automatic cache invalidation: connectome tracks all the changes made to a dataset and automatically invalidates the
    cache when something changes, making sure that your cache is always consistent with the data
  * Invertible transformations: write consistent pre- and post- processing to build production-ready pipelines



  The simplest way is to get it from PyPi:

  ```shell
  pip install connectome
  ```

  Or if you want to try the latest version from GitHub:

  ```shell
  git clone https://github.com/neuro-ml/connectome.git
  cd connectome
  pip install -e .


  pip install git+https://github.com/neuro-ml/connectome.git
  ```



  The docs are located [here](https://neuro-ml.github.io/connectome)

  Also, you can check out our `Intro to connectome` series of
  tutorials [here](https://neuro-ml.github.io/connectome/tutorials/00%20-%20Intro/)



  Some parts of our automatic cache invalidation machinery vere heavily inspired by
  the [cloudpickle](https://github.com/cloudpipe/cloudpickle) project.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  Copyright 2020-2023 NeuroML Group  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: e5cf3cbd782b358bf94f963bfc3d8318377ce6376a3a6bda73821657aca98b5d
name: python-connector-vk-private-lib
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: VK connector
url: https://gitlab.com/films7100147/connector.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connector-vk-private-lib-0.2.5-1.src.rpm
checksum_type: sha256
description:
  This is a simple exercise to publish a package onto PyPi.



  python setup.py sdist bdist_wheel



  twine upload --repository pypi dist/* --skip-existing


pkgId: 50d260168b689b0a49eca5edd39cb55cb98231351dd71494b4d44f371ce24fcb
name: python-connectors-to-databases
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Python module for connect with DataBases
url: https://github.com/yourusername/your-repo
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connectors-to-databases-1.1.8-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/connectors-to-databases?color=blueviolet)
  ![Python](https://img.shields.io/pypi/pyversions/connectors-to-databases?color=blueviolet)
  ![License](https://img.shields.io/pypi/l/connectors-to-databases?color=blueviolet)

  ![PG](https://img.shields.io/badge/PostgreSQL-316192?style=for-the-badge&logo=postgresql&logoColor=white)
  ![PG](https://img.shields.io/badge/ClickHouse-white?style=for-the-badge&logo=clickhouse&logoColor=yellow)

  **Connector to databases** – easy package for connect with database:

  - [ClickHouse](https://github.com/ClickHouse/ClickHouse)
  - [MariaDB](https://github.com/MariaDB/server)
  - [MSSQL](https://www.microsoft.com/en/sql-server/sql-server-2019)
  - [MySQL](https://github.com/mysql/mysql-server)
  - [PostgreSQL](https://github.com/postgres/postgres)-



  Install the current version with
  [PyPI](https://pypi.org/project/connectors-to-databases/):

  ```bash
  pip install connectors-to-databases
  ```

  Or from GitHub:

  ```bash
  pip install https://github.com/k0rsakov/connectors_to_databases/archive/refs/heads/main.zip
  ```



  How to use connections:
  - [ClickHouse.md](doc/ClickHouse.md)
  - [MariaDB.md](doc/MariaDB.md)
  - [MSSQL.md](doc/MSSQL.md)
  - [MySQL.md](doc/MySQL.md)
  - [PostgreSQL.md](doc/PostgreSQL.md)



  Bug reports and/or pull requests are welcome



  ```bash
  python3.11 -m venv venv && \
  source venv/bin/activate && \
  pip install --upgrade pip && \
  pip install -r requirements.txt
  ```




  The module is available as open source under the terms of the
  [Apache License, Version 2.0](https://opensource.org/licenses/Apache-2.0)


pkgId: 5b7b79516e182fcbded1692b92efe734750376f0036b8a2f43ab29d52795f36f
name: python-connegp
arch: src
version: 0.2
epoch: 0
release: 1
summary: This small library module assists with tasks related to Content Negotiation by Profile
url: https://github.com/nicholascar/connegp
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connegp-0.2-1.src.rpm
checksum_type: sha256
description:
  This small library module assists with tasks related to `Content Negotiation by Profile <https://www.w3.org/TR/dx-prof-conneg/>`_, which is a `W3C Standard <https://www.w3.org/standards/>`_ about *how Internet clients may negotiate for content provided by servers based on data profiles to which the content conforms*.


pkgId: 83c8c80c423e9b6e032f86652212c4323a3060f969b6c263fb1a07bd296997a6
name: python-connexion
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Connexion - API first applications with OpenAPI/Swagger
url: https://github.com/spec-first/connexion
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connexion-3.1.0-1.src.rpm
checksum_type: sha256
description:
  Connexion is a modern Python web framework that makes spec-first and api-first development easy.
  You describe your API in an [OpenAPI][OpenAPI] (or [Swagger][Swagger]) specification with as much
  detail as you want and Connexion will guarantee that it works as you specified.
  It works either standalone, or in combination with any ASGI or WSGI-compatible framework!
  <p align="center">
     <br>
     <a href="https://connexion.readthedocs.io/en/latest/v3.html"><strong>📢 Connexion 3 was recently released! Read about the changes here »</strong></a>
     <br>
     <br>
  </p>

  Connexion provides the following functionality **based on your specification**:
  - 🚏 **Automatic route registration**, no ``@route`` decorators needed
  - 🔒 **Authentication**, split from your application logic
  - 🔎 **Request and response validation** of headers, parameters, and body
  - 📬 **Parameter parsing and injection**, no request object needed
  - 📨 **Response serialization**, you can return regular Python objects
  - 📺 **A Swagger UI console** with live documentation and ‘try it out’ feature
  - 🧩 **Pluggability**, in all dimensions
  Connexion also **helps you write your OpenAPI specification** and develop against it by providing a command line interface which lets you test and mock your specification.
  ```shell
     connexion run openapi.yaml
  ```
   <p align="right">(<a href="#top">back to top</a>)</p>

  <a href="https://www.ml6.eu"><img src="https://raw.githubusercontent.com/spec-first/connexion/main/docs/images/sponsors/ML6.png" title=ML6 height="100"></a>
  <a href="https://www.devmark.ai/fern/?utm_source=connexion&utm_loc=readme&utm_type=logo"><img src="https://raw.githubusercontent.com/spec-first/connexion/main/docs/images/sponsors/Fern.png" title=Fern height="100"></a>
  Sponsors help us dedicate time to maintain Connexion. Want to help?
  <a href="https://github.com/sponsors/spec-first"><strong>Explore the options »</strong></a>
  <p align="right">(<a href="#top">back to top</a>)</p>

  With Connexion, you write the spec first. Connexion then calls your Python
  code, handling the mapping from the specification to the code. This
  incentivizes you to write the specification so that all of your
  developers can understand what your API does, even before you write a
  single line of code.
  If multiple teams depend on your APIs, you can use Connexion to easily
  send them the documentation of your API. This guarantees that your API will
  follow the specification that you wrote. This is a different process from
  the one offered by most frameworks, which generate a specification
  *after* you've written the code.
  Some disadvantages of generating specifications based on code is that
  they often end up lacking details or mix your documentation with the implementation
  logic of your application.
  <p align="right">(<a href="#top">back to top</a>)</p>


  You can install connexion using pip:
  ```shell
      $ pip install connexion
  ```
  Connexion provides 'extras' with optional dependencies to unlock additional features:
  - `swagger-ui`: Enables a Swagger UI console for your application.
  - `uvicorn`: Enables to run the your application using `app.run()` for
    development instead of using an external ASGI server.
  - `flask`: Enables the `FlaskApp` to build applications compatible with the Flask
    ecosystem.
  You can install them as follows:
  ```shell
      $ pip install connexion[swagger-ui]
      $ pip install connexion[swagger-ui,uvicorn]
  ```
  <p align="right">(<a href="#top">back to top</a>)</p>

  Connexion can be used either as a standalone application or as a middleware wrapping an existing
  ASGI (or WSGI) application written using a different framework. The standalone application can be
  built using either the `AsyncApp` or `FlaskApp`.
  - The `AsyncApp` is a lightweight application with native asynchronous support. Use it if you
    are starting a new project and have no specific reason to use one of the other options.
    ```Python
        from connexion import AsyncApp
        app = AsyncApp(__name__)
    ```
  - The `FlaskApp` leverages the `Flask` framework, which is useful if you're migrating from
    connexion 2.X or you want to leverage the `Flask` ecosystem.
    ```python
        from connexion import FlaskApp
        app = FlaskApp(__name__)
    ```
  - The `ConnexionMiddleware` can be wrapped around any existing ASGI or WSGI application.
    Use it if you already have an application written in a different framework and want to add
    functionality provided by connexion
    ```python
        from asgi_framework import App
        from connexion import ConnexionMiddleware
        app = App(__name__)
        app = ConnexionMiddleware(app)
    ```
  <p align="right">(<a href="#top">back to top</a>)</p>

  While you can register individual routes on your application, Connexion really shines when you
  register an API defined by an OpenAPI (or Swagger) specification.
  The operation described in your specification is automatically linked to your Python view function via the ``operationId``
  **run.py**
  ```python
     def post_greeting(name: str, greeting: str):  # Paramaeters are automatically unpacked
         return f"{greeting} {name}", 200          # Responses are automatically serialized
     app.add_api("openapi.yaml")
  ```
  **openapi.yaml**
  ```yaml
     paths:
       /greeting/{name}:
         post:
           operationId: run.post_greeting
           responses:
             200:
               content:
                 text/plain:
                   schema:
                     type: string
           parameters:
             - name: name
               in: path
               required: true
               schema:
                 type: string
             - name: greeting
               in: query
               required: true
               schema:
                 type: string
  ```
  <p align="right">(<a href="#top">back to top</a>)</p>

  If you installed connexion using `connexion[uvicorn]`, you can run it using the
  `run` method. This is only recommended for development:
  ```python
      app.run()
  ```
  In production, run your application using an ASGI server such as `uvicorn`. If you defined your
  `app` in a python module called `run.py`, you can run it as follows:
  ```shell
      $ uvicorn run:app
  ```
  Or with gunicorn:
  ```shell
      $ gunicorn -k uvicorn.workers.UvicornWorker run:app


pkgId: d344613b013686818b7f8a8e7b10df0c340040919867513d9753c3bfa0d731ee
name: python-connio
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Concurrency agnostic socket API
url: https://tiagocoutinho.github.io/connio/
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connio-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Pypi version][pypi]

  A python concurrency agnostic communication library.

  Pass a URL to the single point API function `connio.connection_for_url()`
  and it will return a communication object with a common generic API.

  Helpful when dealing with instrumentation which work over serial line or TCP
  (and in future USB) with simple REQ-REP communication protocols (example:
  [SCPI](https://en.m.wikipedia.org/wiki/Standard_Commands_for_Programmable_Instruments)).

  The request for a communication object is forwarded to the corresponding
  [serialio][serialio] or [sockio][sockio] libraries depending on the
  URL you give.

  Written in asyncio with support for different concurrency models:

  * asyncio
  * classic blocking API
  * future based API
  * python 2 compatible blocking API (for those pour souls stuck with python 2)





  From within your favorite python environment:

  ```console
  pip install connio
  ```



  ```python
  import asyncio
  from connio import connection_for_url

  async def main():

      
      sl = connection_for_url("serial:///dev/ttyS0", parity="E")
      print(await sl.write_readline(b"*IDN?\n"))

      
      sl = connection_for_url("rfc2217://moxa.acme.org:7890", parity="E")
      print(await sl.write_readline(b"*IDN?\n"))

      
      tcp = connection_for_url("tcp://gepace.acme.org:5025")
      print(await tcp.write_readline(b"*IDN?\n"))

      
      tcp = connection_for_url("tcp://gepace.acme.org:5025", concurrency="sync")
      print(tcp.write_readline(b"*IDN?\n"))

  asyncio.run(main())
  ```

  [pypi]: https://img.shields.io/pypi/pyversions/connio.svg
  [serialio]: https://github.com/tiagocoutinho/serialio
  [sockio]: https://github.com/tiagocoutinho/sockio


pkgId: 3f19c7a88b808436d4802bee5c96c9c281c02a4579d5fb305bd5b0cfdf85eddf
name: python-connor-nlp
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Fast and fully local NLP file organizer that organizes files based on their content.
url: https://github.com/ycatsh/connor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connor-nlp-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="https://github.com/user-attachments/assets/2987085a-2e8c-4185-9b02-672ba687ca4b" alt="Connor">
  </h1>

  Connor is a file organizer written in [python](https://www.python.org/). It makes use of the [sentence-transformers](https://sbert.net/) framework for the main organization process and the [PyQt6](https://doc.qt.io/qtforpython-6/) GUI toolkit for the graphical user interface. **It is by no means supposed to substitute for organzing files by hand. It is just a concept**. Connor features a fast and fully local file organizer that uses natural language processing to organize computer files based on their textual content.
  <br>

  <div align="center">

  ![releases](https://img.shields.io/github/v/release/ycatsh/connor?color=507591&labelColor=1d1e1f&style=flat)
  ![issues-open](https://img.shields.io/github/issues/ycatsh/connor?color=507591&labelColor=1d1e1f&style=flat)
  ![stars](https://img.shields.io/github/stars/ycatsh/connor?color=507591&labelColor=1d1e1f&style=flat)

  </div>


  Connor works locally on your computer using a pre-trained NLP model `sentence-transformers/paraphrase-MiniLM-L6-v2` to understand the meaning of the data and calculate the cosine similarity between files. The folders are appropriately named using topic modeling through the Latent Dirichlet Allocation (LDA) technique.

  The file names and contents are read, then cosine similarity is used to calculate the similarity between the content of every file with respect to every other file. Based on the condition that the similarity scores between the files are above the provided threshold, the files are grouped in key-value pairs into a dictionary where each category corresponds to a folder.

  Latent Dirichlet Allocation is then used to generate topic names for the contents in each folder, i.e., the categories in the dictionary. Folders are created using the most relevant topic names, and the corresponding files are then moved into their appropriate folders.

  For files such as images (image support will be added later), executables, binaries, etc. that cannot be read are organized into a ``_misc`` folder based on their file extensions.

  <br>


  1. Organize files within a selected folder or manually uploaded files (uploading files is only supported for GUI).
  2. Organize text-based files (`.docx`, `.txt`, `.pdf`, etc.) using NLP.
  3. Creates a separate folder named "Miscellaneous" for dissimilar or unprocessable files based on extension.
  4. Provide a summary (tree structure) of the organization process upon completion.


  1. Similarity Threshold: Allows you to choose a similarity percentage threshold for grouping similar files.
  2. Reading Word Limit: You can set a limit on the number of words to read from the file content.
  3. Folder Name Word Limit: You can specify the maximum number of words allowed in the created folder names.
  4. Default Parameters: You can modify these three parameters and save them for future sessions.


  Command Line Interface: Simple and concise command line interface to quickly organize folders.
  Graphical User Interface: Provides a simplistic and straightforward GUI for ease of use with upload files feature.


  <br>
  <br>



  There are installation instructions for both GUI and CLI. You can choose the one you want to install. If you're opting for building the application from [source](https://github.com/ycatsh/connor#source) then adding the run file to path is recommended.

  **Install Connor via pip:**
  1. Make sure you have `python` and `pip` installed and added to path.
  2. Run `pip install connor-nlp`

  <br>

  **Install the GUI version of Connor (executable)**
  1. Go to the [latest release](https://github.com/ycatsh/connor/releases).
  3. Follow the steps there.
  2. Run the executable (`.exe`).


  <br>
  <br>






  ```bash
  connor [command] [options]
  ```




  **Usage:**
  ```bash
  connor run <folder_path>
  ```

  **Options:**
  - `folder_path`: Required. Absolute path to the folder that you want to organize.

  **Example:**
  ```bash
  connor run /path/to/your/folder
  ```

  <br>



  **Usage:**
  ```bash
  connor settings [options]
  ```

  **Options:**
  - `-f, --folder-word-limit`: Set the maximum length for folder names. (default: 3)
  - `-r, --reading-limit`: Specify the word limit for reading files. (default: 200)
  - `-t, --similarity-threshold`: Define the similarity threshold percentage. (default: 50)
  - `--show`: Show current settings

  **Example:**
  ```bash
  connor settings -f 2 -r 150 -t 60
  ```

  ```console
  $ connor settings --show
  To see how to update: Connor settings [-h]

  Current settings:
    folder words limit     3
    reading limit          200
    similarity threshold   50%
  ```

  <br>



  **Usage:**
  ```bash
  connor --gui
  ```

  <br>


  To view help information for commands and options use the ``-h`` or `--help` flag.

  **Example:**
  ```console
  $ connor -h
  usage: Connor [-h] [--gui] {settings,run} ...

  Connor: Fast and local NLP file organizer

  positional arguments:
    {settings,run}
      settings      Update the settings for the organizer
      run           Run the folder organization process

  options:
    -h, --help      show this help message and exit
    --gui           Run the application in GUI mode.
  ```

  <br>
  <br>




  ```bash
  git clone https://github.com/ycatsh/connor.git
  cd connor
  ```

  ```bash
  python3 -m venv venv
  source venv/bin/activate
  ```

  ```bash
  pip3 install -r requirements.txt
  ```

  For GUI:
  ```bash
  python3 run.py --gui
  ```
  For CLI:
  ```bash
  python3 run.py -h
  ```


  ```bash
  pip3 install .
  ```

  **Example:**
  ```bash
  connor --gui
  ```
  ```bash
  connor -h
  ```


  <br>
  <br>



  This project is distributed under MIT License, which can be found in LICENSE in the root dir of the project. I reserve the right to place future versions of this project under a different license.


pkgId: 810aaddf82d05534a055477387179165cbe1d18fd7e9cac19e21540d4038ba4e
name: python-connord
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Connect to NordVPN servers
url: https://github.com/MaelStor/connord
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connord-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Connord connects to NordVPN servers by wrapping
  [OpenVPN](https://openvpn.net/community-resources/#articles) and iptables. Most
  tools, including the official nordvpn app do not allow customising iptables
  properly. Often, iptables rules are left in a mess when finished and may even
  lead to unexpected behaviour. Additionally, the native openvpn application lacks
  kind of connection profiles, to easily switch between configurations depending
  on your network you are currently using, for example on your laptop. Connord
  connects you to NordVPN servers, wrapping openvpn and iptables to provide a
  rich, powerful and simple to use tool chain orchestrated from the command line.
  This tool is not for you, if you want to connect to nordvpn servers via NordLynx
  or use other special nordvpn technologies. Connord connects you via openvpn over
  the udp port 1196 or tcp port 443. If openvpn is patched correctly it connects
  you to obfuscated servers. This should cover the most use cases, but it won't do
  anything more... Use the official nordvpn tool instead if you wish to use
  CyberSec etc.
  However, compared to other tools, connord can deliver more information about
  servers, areas, countries etc., easily accessible from the command line, with
  its extensive filters. It also uses a powerful and yet simple mechanism to
  determine the fastest NordVPN server for your location without gathering any
  information about your exact place. It is less intrusive than other tools
  because there is no need to install systemd services per default and just works
  within your terminal.

  If you're already using connord and want to update from an earlier version it is
  best to completely uninstall connord first. Then follow the Installation
  instructions from this document. Connord is still under development and each
  minor version (the `x` in `0.x.y`) difference is not backwards compatible. Save
  your configuration files and adjust them to the new ones if necessary.
  Currently, (as of `0.6.0`) only the `/etc/connord/config.yml` file has
  additional configuration options. Iptables rules and fallback files still follow
  the same scheme but the variables exposed to `.rules` and `.fallback` files
  have changed. The 'lan' and 'gateway' dictionaries were removed. Instead, there
  is the new 'gateways' dictionary available. For a complete description see the
  changed [Variables](#Variables) section. The default `.rules` and `.fallback`
  coming with connord have changed to support a wider range of systems and an
  easy start with connord.

  - iptables
  - openvpn
  - Either resolvconf or systemd-resolved to correctly route the dns traffic
  - and the python package dependencies of connord. See Installation section.

  - Follow Installation instructions below
  - Download or update the openvpn configuration files for nordvpn with
    `$ sudo connord update`.
  - Execute `$ sudo connord connect -c YOUR_COUNTRY_CODE` and replace
    YOUR_COUNTRY_CODE with the country code of your current country. List all
    country codes with `$ connord list countries`. You will be asked for your
    username and password which are stored safely in
    `/etc/connord/openvpn/nordvpn/credentials`.

  Install the system dependencies depending on your distribution with

      $ sudo apt-get update
      $ sudo apt-get install iptables openvpn

      $ sudo pacman -Sy iptables openvpn
  For the up down scripts of openvpn there needs either `resolvconf` or
  `systemd-resolved` to be installed and configured on your system. Connord
  automatically detects which one is used. Other systems are currently not
  natively supported, but by providing own `openvpn_up_down` scripts this can be
  circumvented.

  This is currently the recommended method to install connord, because it creates
  all the directories needed in `/etc/connord` to get the most out of connord.
      $ git clone https://github.com/MaelStor/connord
      $ cd connord
      $ sudo make install
  Remark, that this doesn't install the dependencies of connord, since your
  distribution most likely offers packages for them, and this is usually the best
  way to go, so you are best advised to install the dependencies of connord with
  your distribution's package manager. In case you don't want to manage python
  dependencies with the distribution's package manager, you can still install
  connord with `pip` (See below). Installation of the python packages:

      $ sudo apt-get install python3-cachetools python3-jinja2 python3-netaddr \
          python3-netifaces python3-progress python3-iptables python3-yaml \
          python3-requests python3-setuptools

  You need to install the `python-iptables` package from the aur repository. So
  for example with pacaur execute:
      $ sudo pacaur -Sy python-cachetools python-jinja python-netaddr \
          python-netifaces python-progress python-iptables python-yaml \
          python-requests python-setuptools
  You can start right off or customize connord in `/etc/connord/config.yml` and
  adjust the iptables rules in `/etc/connord/iptables/*`.

      $ pip install --user --upgrade connord
  You need to run commands that need root access with
      $ sudo $(which connord) connect -c de
  instead. Global installation although not recommended since this also installs
  the dependencies of connord globally:
      $ sudo pip install --upgrade connord

  All configuration files since version 0.5.0 reside in the `/etc/connord`
  hierarchy. The configuration files are documented with the most recent
  configuration values. Here just a quick overview to get started.
  The main configuration file is `/etc/connord/config.yml`. Iptables rules can be
  adjusted in `/etc/connord/iptables/`.

  The main configuration file in [YAML](https://yaml.org/) format. Every variable
  set within this configuration file is exposed to .rules and .fallback
  iptables templates.

  This section may look like this:
  <pre>
  iptables
    dns:
      
      - '103.86.99.100/32'
      - '103.86.96.100/32'
  </pre>
  Use these variables for example in 01-filter.rules:
  <pre>
  OUTPUT:
    policy: ACCEPT
    action: None
    rules:
  {% for server in iptables.dns %}
    - dst: "{{ server }}"
      protocol: udp
      udp:
        dport: '53'
      target: ACCEPT
  {% endfor %}
  </pre>
  what creates the following after rendering:
  <pre>
  OUTPUT:
    policy: ACCEPT
    action: None
    rules:
    - dst: '103.86.99.100/32'
      protocol: udp
      udp:
        dport: '53'
      target: ACCEPT
    - dst: '103.86.96.100/32'
      protocol: udp
      udp:
        dport: '53'
      target: ACCEPT
  </pre>
  Rendering is happening automatically, so no user side intervention is required.

  The settings which are used to start openvpn can be found in `config.yml`. For
  an overview of all possible options see `$ man openvpn`. You just need to strip
  off the leading '--' and place it somewhere in the openvpn section. Arguments
  are written after `:` or if the option doesn't take any arguments place `True`
  after `:`. Further reading
  about [YAML Syntax](https://yaml.org/spec/1.1/spec.html). There's the special
  keyword
  `built-in`, which can be applied to:
  - auth-user-pass
  - scripts paths
      - name: up
      - name: down
      - name: ipchange
  if you like to use the built-in paths, what is the default behaviour. If you
  don't like to run a script say when openvpn goes down delete or comment out
  <pre>
      - name: "down"
        path: "built-in"
        stage: "down"
        creates: "down.env"
  </pre>

  The iptables rules reside in `/etc/connord/iptables`.

  These files are [jinja2](http://jinja.pocoo.org/docs/2.10/) templates which are
  rendered with the `config.yml` file and `.env` files created by the built-in
  `up`, `down` and `ipchange` scripts when openvpn starts running.

  Let's take for example the rules file which shall be applied to netfilter's
  `filter` table. `01-filter.rules`. The leading number isn't necessary, but that
  way you can control the order when to apply the files. After the optional dash
  follows the table name. The dash isn't needed when there is no leading number.
  The suffix `.rules` causes the rules to be applied after successfully
  establishing a connection to a server. The suffix `.fallback` causes the rules
  to be applied when disconnecting from a server or after invocation of `connord
  iptables flush`. If you're writing ipv6 rules for the `filter` table place them
  in a file like `01-filter6.rules` or `01-filter6.fallback`.

  Every variable you define or is already defined in `config.yml` is available in
  iptables rules files. In addition to that the connord instance exposes the
  following variables to `.rules` and `.fallback` files:
  <pre>
  vpn_remote      # the remote server ip address
  vpn_protocol    # the protocol in use: udp or tcp
  vpn_port        # may be 1194 (udp) or 443 (tcp)

  gateways.default = (ip_address, interface)



  gateways.default_inet6


  gateways.other = [(ip_address, interface), ... ]


  gateways.other_inet6

  </pre>
  In `fallback` files `vpn_remote` is `0.0.0.0/0`, `vpn_protocol` is `udp` and
  `vpn_port` is set to `1194`.
  Variables exposed from OpenVPN scripts can be seen when starting connord not in
  daemon mode. The list given here may be incomplete or too exhaustive for your
  network and is therefore just an incomplete preview. Look at the output of
  connord for your environment. For example here the variables from `up.env` when
  the connection is started by openvpn.
  <pre>
  connord 'up' environment variables: '/var/run/connord/up.env'
  up_args:
    - 'init'
    - '255.255.255.0'
    - '10.8.1.10'
    - '1590'
    - '1500'
    - 'tun1'
    - '/var/run/connord/up.env'
  dhcp_option:
    dns:
      - '103.86.99.100'
      - '103.86.96.100'
  dev: 'tun1'
  ifconfig_broadcast: '10.8.1.255'
  ifconfig_local: '10.8.1.10'
  ifconfig_netmask: '255.255.255.0'
  link_mtu: '1590'
  route_net_gateway: '200.200.200.200'
  route_vpn_gateway: '10.8.1.1'
  script_context: 'init'
  tun_mtu: '1500'
  trusted_ip: '100.100.100.100'
  trusted_port: '1194'
  untrusted_ip: '100.100.100.100'
  untrusted_port: '1194'
  redirect_gateway: 1
  </pre>
  Variables from OpenVPN scripts are only available in `.rules` files, not
  `.fallback` files.

  Command-line options overwrite the configuration in `config.yml`. This is mostly
  important for the openvpn command line options passed through to openvpn. To
  connect to nordvpn servers and alter iptables rules connord needs to be executed
  as root. Most subcommands, especially the list subcommand, do not need root
  access.

  First, list all possible commands with `$ connord --help`. Any sub command has a
  help and can be accessed with `$ connord SUBCOMMAND --help`. Before connecting
  to a server and execute connord with root rights, you may wish to play around
  with connord commands and start with listing servers `$ connord list servers`.
  See below for more information about the list subcommand.

  Connecting to nordvpn servers is done with `$ sudo connord connect`. No further
  options are required, but limiting the possible servers may be what you want if
  you want a faster connection. However, connord tries its best to figure out the
  best server. Internally it sorts the servers by load and then by their ping.
  Then it tries to connect to the server with the lowest load and lowest ping.
  For instance, if limiting servers to the country you're living in is what you
  want, pass the `--country COUNTRY_CODE` to the connect command. The country code
  is a two letter abbreviation of a country. All possible country codes can be
  listed with `$ connord list countries`.
  There are many other options to filter the servers connord tries to connect to.
  See `$ connord connect --help` for all possible options.

  Managing iptables with connord can be done with `$ connord iptables ACTION`
  where valid ACTIONs can be listed with `$ connord iptables --help`. Before
  taking any action make sure to save your original iptables rules. This can be
  done for example with `$ sudo iptables-save > /etc/iptables/iptables.rules`. For
  your safety any connord command modifying system files and iptables rules needs
  root access for example with sudo.

  List all possible countries, features, categories (types), servers, iptables
  rules etc. See what is possible with `$ connord list --help`. All sub commands
  to the list command try to help with the usage of connord or provide additional
  information about a topic.

  Listing servers can be done with `$ connord list servers`. As with the connect
  command, there are a lot of options to limit the servers in the output. The
  output of the list command may help in figuring out which servers are available
  or help with the connect command. Most options here are also available in the
  connect command, so running the `list servers` command beforehand helps to
  reduce the servers to the servers you really want to wish to connect to. More
  help can be seen with `$ connord list servers --help`.

  Updating the configuration files and database must be done once after
  installation and after that on a regular basis to ensure connord uses the latest
  possible servers and correct openvpn configuration.
  To do so, just execute `$ connord update`

  Have a look at the output of `$ connord list features`

  All supported types are listed with `$ connord list categories`. The term
  `types` and `categories` are used interchangeably

  If you experience problems running connord, first try the same command in
  verbose mode with
      connord -v COMMAND
  or
      connord --verbose COMMAND
  You should see in most cases where the error occurred. There may be still hard
  to track bugs, please report them to the Issue board on
  [Github](https://github.com/MaelStor/connord/issues).
  Error messages are written to stderr in your shell. You can suppress error
  messages with `-q` or `--quiet` if you like to.
  Verbose mode of `openvpn` can be set in `config.yml` in the openvpn section or
  at the command-line when using `connord connect` adding it to the openvpn
  command with `-o '--verb 3'`.

  In order to be able to connect to obfuscated servers you need to
  [patch](https://github.com/clayface/openvpn_xorpatch) OpenVPN. For example the
  repository of [Tunnelblick](https://github.com/Tunnelblick/Tunnelblick) includes
  the patches in third_party/sources/openvpn. How this can be done is described
  [here](https://www.reddit.com/r/nordvpn/comments/bsbxt6/how_to_make_nordvpn_obfuscated_servers_work_on/)
  . I haven't patched my openvpn client, so I can't share experiences but above
  solution is reported to work.
  You can list obfuscated servers with `$ connord list servers -t obfuscated`.
  Same scheme to finally connect to an obfuscated server for example located in
  HongKong: `$ sudo connord connect -c hk -t obfuscated`.

  Make sure to have `poetry` installed. Clone the repo and install the development
  environment:
      $ git clone git@github.com:MaelStor/connord.git
      $ cd connord
      $ make develop

  Thanks to Jonathan Wright @ https://github.com/jonathanio for his great
  update-systemd-resolved
  script (https://github.com/jonathanio/update-systemd-resolved)


pkgId: 4256228484ab27715e031d1674236f5b70f5b7b6b17dc04a048ce3a023024e98
name: python-connpy
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: Connpy is a SSH/Telnet connection manager and automation module
url: https://github.com/fluzzi/connpy
rpm_license: Custom Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-connpy-4.1.1-1.src.rpm
checksum_type: sha256
description:
  **Endpoint**: `/get_nodes`
  **Method**: `POST`
  **Description**: This route returns a dictionary of nodes with all their attributes. It can also filter the nodes based on a given keyword.

  ```json
  {
    "filter": "<keyword>"
  }
  ```
  * `filter` (optional): A keyword to filter the nodes. It returns only the nodes that contain the keyword. If not provided, the route will return the entire list of nodes.


pkgId: 59e062d5bef22735d1888fca6e6d79af4d2257eef2d8ee23c499947a18f1f542
name: python-cons
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: An implementation of Lisp/Scheme-like cons in Python.
url: https://github.com/pythological/python-cons
rpm_license: LGPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cons-0.4.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/pythological/python-cons.svg?branch=main)](https://travis-ci.org/pythological/python-cons) [![Coverage Status](https://coveralls.io/repos/github/pythological/python-cons/badge.svg?branch=main)](https://coveralls.io/github/pythological/python-cons?branch=main) [![PyPI](https://img.shields.io/pypi/v/cons)](https://pypi.org/project/cons/)



  An implementation of [`cons`][cons] in Python.



  The `cons` package attempts to emulate the semantics of Lisp/Scheme's `cons` as closely as possible while incorporating all the built-in Python sequence types:
  ```python
  >>> from cons import cons, car, cdr
  >>> cons(1, [])
  [1]

  >>> cons(1, ())
  (1,)

  >>> cons(1, [2, 3])
  [1, 2, 3]
  ```

  In general, `cons` is designed to work with `collections.abc.Sequence` types.

  According to the `cons` package, `None` corresponds to the empty built-in `list`, as `nil` does in some Lisps:
  ```python
  >>> cons(1, None)
  [1]
  ```

  The `cons` package follows Scheme-like semantics for empty sequences:
  ```python
  >>> car([])
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ConsError: Not a cons pair

  >>> cdr([])
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ConsError: Not a cons pair

  ```

  By default, `str` types are not considered cons-pairs, although they are sequences:
  ```python
  >>> cons("a", "string")
  ConsPair('a' 'a string')
  ```

  This setting can be overridden and other types can be similarly excluded from consideration by registering classes with the `abc`-based classes `MaybeCons` and `NonCons`.




  * Built-in support for the standard Python ordered sequence types: i.e. `list`, `tuple`, `Iterator`, `OrderedDict`.
  ```python
  >>> from collections import OrderedDict
  >>> cons(('a', 1), OrderedDict())
  OrderedDict([('a', 1)])

  ```
  * Existing `cons` behavior can be changed and support for new collections can be added through the generic functions `cons.core._car` and `cons.core._cdr`.
  * Built-in support for [`unification`][un].
  ```python
  >>> from unification import unify, reify, var
  >>> unify([1, 2], cons(var('car'), var('cdr')), {})
  {~car: 1, ~cdr: [2]}

  >>> reify(cons(1, var('cdr')), {var('cdr'): [2, 3]})
  [1, 2, 3]

  >>> reify(cons(1, var('cdr')), {var('cdr'): None})
  [1]

  ```



  ```python
  pip install cons
  ```



  First obtain the project source:
  ```bash
  git clone git@github.com:pythological/python-cons.git
  ```

  Create a virtual environment and install the development dependencies:
  ```bash
  $ pip install -r requirements.txt
  ```

  Set up `pre-commit` hooks:

  ```bash
  $ pre-commit install --install-hooks
  ```

  [cons]: https://en.wikipedia.org/wiki/Cons
  [un]: https://github.com/pythological/unification


pkgId: 6f94a3347140df2de0f00f4970e1d23d8ee5c814a289ea14feea88eaff0899d3
name: python-conscript
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Conscript console scripts in your own Swiss Army Knife.
url: https://github.com/jsirois/conscript
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conscript-0.1.8-1.src.rpm
checksum_type: sha256
description:
                                       \
                                        \
                                          ^__^
                                          (oo)\_______
                                          (__)\       )\/\
                                              ||----w |
                                              ||     ||
      ```
  4. Or another one:
      ```console
      $ ./speak fortune -h
      Usage: speak [OPTIONS] [fortune_file]
      Options:
        -h, --help     show this help message and exit
        -V, --version  Show version and exit.
      If fortune_file is omitted, fortune looks at the FORTUNE_FILE environment
      variable for the path.
      $ ./speak fortune /usr/share/fortune/science
      Nondeterminism means never having to say you are wrong.
      ```
  5. Target an embedded app via a symlink:
      ```console
      $ ln -s speak cowsay
      $ ./cowsay Nifty.
        ______


pkgId: c06a21f975e7c4a909854b4c964e07ebfc2a5c638427ed09cd6e9d04c61cb2cf
name: python-consensusGen
arch: src
version: 2.7
epoch: 0
release: 1
summary: Genetic algorithm for consensus building
url: https://pypi.org/project/consensusGen/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consensusGen-2.7-1.src.rpm
checksum_type: sha256
description:
  `consensusGen.py` is a Python code implementing an genetic algorithm allowing to build a consensus value from measurement results of an inter-laboratory comparison.

  Details are provided in [Romain Coulon and Steven Judge 2021 Metrologia 58 065007](https://doi.org/10.1088/1681-7575/ac31c0)

  The code is developped and maintained by the BIPM (MIT license).


pkgId: 5b4601bf3ed954e56e3e043021b92ffa47795e96bc02b452c18b17afd148d6ad
name: python-consensusclustering
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Python implementation of Consensus Clustering by Monti et al. (2003)
url: https://pypi.org/project/consensusclustering/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consensusclustering-0.2.3-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/consensusclustering)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/consensusclustering)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/consensusclustering)
  ![PyPI - License](https://img.shields.io/pypi/l/consensusclustering)
  ![Codecov](https://img.shields.io/codecov/c/github/burtonrj/consensusclustering)
  ![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/burtonrj/consensusclustering/build.yaml)



  `consensusclustering` is a python implementation of the Consensus Clustering
  algorithm for finding the optimal number of clusters by means of clustering
  stability under resampling, as originally proposed by [Monti et al. Consensus
  Clustering: A Resampling-Based Method for Class Discovery and Visualization of Gene
  Expression Microarray Data (2003)](https://link.springer.com/article/10.1023/A:1023949509487).



  `consensusclustering` can be installed from PyPi using pip:

  ```bash
  pip install consensusclustering
  ```



  See the 'examples' directory for a detailed overview of the package's functionality.



  Cytotransform is licensed under the MIT license, is free to use, and comes with no warranty whatsoever.


pkgId: f80a52a967b03fcf08bc1b50b7842e553a44ea62bc39be43150f6f1a0d7a258c
name: python-conservator-cli
arch: src
version: 2.15.1
epoch: 0
release: 1
summary: A library for using the Teledyne FLIR Conservator API, with a nice command line interface.
url: https://github.com/FLIR/conservator-cli
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conservator-cli-2.15.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://jenkins.conservator.ai/buildStatus/icon?job=conservator_cli)](https://jenkins.conservator.ai/job/conservator_cli/)

  This library provides a Python API to interface with
  [Conservator](https://flirconservator.com/), as well as a CLI for
  simple operations like searching, downloading, and uploading files.

  Please visit the [Official Documentation](https://flir.github.io/conservator-cli/)
  to get started.

  Conservator CLI is licensed under the [MIT License](https://opensource.org/licenses/MIT).


pkgId: 797a2991f25d83f1772df6b5c53880cf55e7275a2e78e9411181c6f7eca0eec3
name: python-consilio
arch: src
version: 0.1
epoch: 0
release: 1
summary: A Personal Decision Making Tool powered by LLMs
url: https://github.com/yourusername/consilio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consilio-0.1-1.src.rpm
checksum_type: sha256
description:
  > "Consilio" is a Latin term that embodies concepts such as counsel,
  > deliberation, and wisdom. In ancient times, "consilium" referred to a group
  > of advisors or a council that deliberated on important decisions, reflecting
  > a process of careful consideration and planning. The term is associated with
  > strategic thinking and prudent decision-making, emphasizing the use of good
  > judgment, experience, and advice.



  Consilio helps you make better decisions but it does not make decisions for you. As Thomas Sowell said: “It is hard to imagine a more stupid or more dangerous way of making decisions than by putting those decisions in the hands of people who pay no price for being wrong.”

  Consilio leverages LLM by asking independent questions and seek out opinions from multiple perspectives. Think of it as a vast
  support network of advisors.  It asks you questions like "Have you thought about ...",  "What if ...", "Let's
  stress test it this way ...".  The kind of questions you often pay your
  advisors or boards for.

  Consilio is intentionally minimal. It is designed to be used
  in a command-line environment with a text editor (e.g., vim).

  The core artefact Consilio works around is a single `DECISION.md` document. As
  you go through the thinking process, you will revise this document by answering
  the questions posed by Consilio.

  All intermediate steps are preserved in structured format within a date-stamped
  directory, creating a detailed record of the decision-making process. This
  allows for both immediate reference and retrospective review of how important
  decisions were made.

  Think of Consilio as the "formal scientific method".  It can be "slow, tedious, lumbering, laborious but invincible".



  ```bash
  $ consilio Decisions/BankLoan.md
  Welcome to Consilio.

  May you make wise decisions.

  Decision document: Decisions/BankLoan.md
  Domain: "a NZ-based B2C iOS app startup that are pre-product-market-fit"
  Advisor Perspective: "an bootstrapped B2C founder, who successfully navigated pre-PMF phase with limited capital. , living outside of US but your main market is US."
  User Role:"Solo Founder"

  Get get started, please select one of the following actions: observe, consult.
  CTRL+C to exit.

  > observe
  [Response in Markdown format]
  {You noticed that you need to provide more context. You update the document in your editor. Now, let's try again.}
  > observe
  [...]
  {You are happy with the quality of the questions and decide to proceed.}
  > consult
  [Response from the assembly step]
  Are you ready to proceed to the consult step? (Y/n) Y
  [Opinions from each perspectives]
  {You noticed a gap in the information and decide to go back to the observe step.}
  > consult
  [...]

  {When you gut feel tells you that you have enough information to make a decision. }

  CTRL+C received.  Exiting.
  ```



  Create a new `.consilio.yml` file in the root directory with the following
  structure:

  ```yaml
  domain:"a NZ-based B2C iOS app startup that are pre-product-market-fit"
  perspective:"an bootstrapped B2C founder, who successfully navigated pre-PMF phase with limited capital. , living outside of US but your main market is US."
  user_role:"Solo Founder"
  ```

  Consilio can load different context through the command line option.

  ```bash
  consilio --context marketing.consilio.yml
  ```

  Further, the yaml settings can be overridden by the user at the start of the session.


pkgId: c82c7f04a2a116b55bbfd11d382c492b1f771966e757455f27655e74b118994f
name: python-console
arch: src
version: 0.9909
epoch: 0
release: 1
url: https://github.com/mixmastamyk/console
rpm_license: LGPL 3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-0.9909-1.src.rpm
checksum_type: sha256
summary:
  Comprehensive, composable utility library for ANSI terminals. Better, stronger, faster.  Tch-tch-tch-tch…

description:
      - *"👍 Ayyyyyy… 👍"—The Fonz*
      - *"DYN-O-MITE!!" —J.J. from Good Times*
      - *“Better… Stronger… Faster” —Oscar Goldman*
      - *"There is nothing we won't try…" —Laverne and Shirley*
      - *"You're gonna eat lightning and crap thunder!"—Mickey Goldmill*
      - *"Nothin' can stand in our way…" —Olivia Newton-John*
      - *"Fightin' the system like a true modern-day Robin Hood" —Waylon Jennings*
  |
  Yet another package that makes it easy to generate the inline codes used to
  display colors and character styles in ANSI-compatible terminals and emulators,
  as well as other functionality such clearing screens,
  moving cursors,
  setting title bars,
  and detecting capabilities.
  How is this one different?
  Well,
  it's highly composable and more comprehensive than most.
  How does it work?
  It's a piece of cake.
      *"Piece of cake?
      Oh, I wish somebody would tell me what that means." —Dr. Huer*


pkgId: dde1635348b04468857c88eb5cacc72fa1b603a9a2cdea30b64a9da0c38e6fef
name: python-console-ctrl
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Send CTRL-C event to a target console process WITHOUT causing KeyboardInterrput at the caller side.
url: https://github.com/arvinpan/console-ctrl
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-ctrl-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This simple package allows you to send CTRL-C event to a target console process WITHOUT causing KeyboardInterrput at the caller side.

  The solution is based on posts shared on stackoverflow (see Reference for details).



  Install with `pip install console-ctrl`

  In you code:

  ```python
  import console_ctrl
  import subprocess


  p = subprocess.Popen(['some_command'], creationflags=subprocess.CREATE_NEW_CONSOLE)


  console_ctrl.send_ctrl_c(p.pid)
  ```

  Note: the target process should be started with `creationflags=subprocess.CREATE_NEW_CONSOLE`.



  Specially thanks to people shared solutions here:

  - https://stackoverflow.com/questions/7085604/sending-c-to-python-subprocess-objects-on-windows
  - https://stackoverflow.com/questions/813086/can-i-send-a-ctrl-c-sigint-to-an-application-on-windows

  More official docs:

  - https://docs.microsoft.com/en-us/windows/console/generateconsolectrlevent
  - https://docs.python.org/3/library/subprocess.html


pkgId: 53444b7f558029de861311b99d8d96384d82d897841a3761919f2aa4683c115f
name: python-console-games
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Fun games for macOS/Linux console!
url: https://github.com/maxzheng/console-games
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-games-0.3.5-1.src.rpm
checksum_type: sha256
description:
  Four games are available:
  1. **Geometry Bash**: Bash the squares before they get you and watch out for the money boss! Don't like geometry? You will love this one!! :D
  2. **Planet X**: You have been transported to Planet X thru a wormhole. Fly thru obstacles and wormholes to get back home! Game design by my kids.
  3. **Number Crush**: Great game to train your kids' basic math skill. Answer quickly or get crushed. My son needs to crush 5 to earn 1 minute of screen time and loves doing it daily. :)
  4. **Wasp Invasion**: Wasp kaijus have invaded Earth! Luckily, you got your flamethrower with you to save the day. FLAMES ON!!
  5. **THE LAST SURVIVOR!!**: Kill the zombies to survive the apocalypse where you are the last survivor. Level up to get machine gun, grenades, and flamethrower!! Game design by my kids.
  To play using Docker::
      docker run -it --rm maxzheng/console-games
  To install using autopip_::
      sudo pip3 install autopip
      app install console-games
  If you have trouble using `autopip`, you can install using `pip3` directly too::
      pip3 install console-games
  And then start playing::
      play
  Enjoy! And come back soon for more games!!


pkgId: bc9e19c69d76b72a553b7ebfd88409fcd13e8bd230946941fa02c9b4d1aafa73
name: python-console-logging
arch: src
version: 0.0.5.0
epoch: 0
release: 1
summary: Better, prettier commandline logging.
url: https://github.com/pshah123/console-logging
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-logging-0.0.5.0-1.src.rpm
checksum_type: sha256
description:
  |Codeship Status for pshah123/console-logging| |PyPI version| |Codacy
  Badge|
  Better console logging for Python.
  Find us on PyPi: https://pypi.python.org/pypi/console-logging
     Showcase


pkgId: dbe65e7793eae56fef27cac18c40df416eb11493e3ac6a738deb173720f8c211
name: python-console-menu
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A simple console menu system
url: http://github.com/aegirhall/console-menu
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-menu-0.8.0-1.src.rpm
checksum_type: sha256
description:
  A simple Python menu-based UI system for terminal applications.
  Perfect for those times when you need a menu-driven program, but don’t want the
  overhead or learning curve of a full-fledged GUI framework.
  Derived from the curses-menu project, but with curses dependency removed.
  http://console-menu.readthedocs.org/en/latest/
  Installation
  ~~~~~~~~~~~~
  Tested on Python 3.7 - 3.11, as well as pypy and pypy 3.
  Installation can be performed by running pip
     pip install console-menu


pkgId: 49fd273ec2508e38a51a05164d3bf665f8f9e6a8c50c5528a01033bedd8e0e28
name: python-console-sudoku
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A simple command-line version of the classic game Sudoku!
url: https://github.com/SulKhu/Sudoku
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-console-sudoku-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This is a command-line version of the classic game Sudoku. Make sure your have Python 3.12 installed

  To start a game of sudoku after installing console_sudoku, run a python shell and type: "from console_sudoku import game". Then, simply type: "game.run()" and then follow the instructions of the game!

  To play the game of sudoku, make sure to copy the puzzle exactly and return the exact same puzzle with the spaces replaced with numbers to not throw an exception.

  Have fun!


pkgId: 08642aafc03c6f8e9e5dbdeb2d9b877a094ebc3b80fdb1ba98b7480276827e6c
name: python-consolekit
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: Additional utilities for click.
url: https://github.com/domdfcoding/consolekit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consolekit-1.7.1-1.src.rpm
checksum_type: sha256
description:
  ``consolekit`` can be installed from PyPI or Anaconda.
  To install with ``pip``:
  	$ python -m pip install consolekit
  To install with ``conda``:
  	* First add the required channels
  		$ conda config --add channels https://conda.anaconda.org/conda-forge
  		$ conda config --add channels https://conda.anaconda.org/domdfcoding
  	* Then install
  		$ conda install consolekit
  Additionally, for better support in terminals,
  install `psutil <https://pypi.org/project/psutil/>`_ by specifying the ``terminals`` extra:
  	$ python -m pip install consolekit[terminals]
  or, if you installed ``consolekit`` through conda:
  	$ conda install -c conda-forge psutil


pkgId: 03dd7a9fa32acba68f516cb55359ad66ffd6e6fc9959a8c50248da84e935856a
name: python-consolemd
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: ConsoleMD renders markdown to the console
url: https://github.com/kneufeld/consolemd
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consolemd-0.5.1-1.src.rpm
checksum_type: sha256
description:
  ConsoleMD parses markdown using CommonMark-py (implementation of the
  CommonMarkdown spec) and then fully renders it to the console in true color.


pkgId: edb73279cbbd1002275204a3f05385bf06d64fc7cfe4e219d338c1375bf27309
name: python-consoleme
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A central control plane for AWS permissions and access
url: https://github.com/Netflix/ConsoleMe
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consoleme-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://www.python.org/downloads/release/python-3105/)
  [![Discord](https://img.shields.io/discord/730908778299523072?label=Discord&logo=discord&style=flat-square)](https://discord.gg/nQVpNGGkYu)



  Check out our [quick start guide](https://hawkins.gitbook.io/consoleme/quick-start)
  , [documentation](https://hawkins.gitbook.io/consoleme/)
  , [feature videos](https://hawkins.gitbook.io/consoleme/feature-videos)
  , [ReInvent Talk](https://www.youtube.com/watch?v=fXNRYcNyw0c&t=5s),
  and [Blog Post](https://netflixtechblog.com/consoleme-a-central-control-plane-for-aws-permissions-and-access-fd09afdd60a8)
  .



  ConsoleMe is a web service that makes AWS IAM permissions and credential management easier for end-users and cloud
  administrators.

  ConsoleMe provides [**numerous
  ways**](https://hawkins.gitbook.io/consoleme/feature-videos/credentials/aws-console-login) to log in to the AWS Console.

  An [**IAM Self-Service
  Wizard**](https://hawkins.gitbook.io/consoleme/feature-videos/policy-management/self-service-iam-wizard) lets users
  request IAM permissions in plain English. Cross-account resource policies will be automatically generated, and can be
  applied with a single click for certain resource types.

  [Weep](https://github.com/Netflix/weep) (ConsoleMe’s CLI) supports [**5 different
  ways**](https://hawkins.gitbook.io/consoleme/weep-cli/cli) of serving AWS credentials locally.

  Cloud administrators can [**create/clone IAM
  roles**](https://hawkins.gitbook.io/consoleme/feature-videos/policy-management/role-creation-and-cloning) and natively [**manage
  IAM roles, users, inline/managed policies, S3 Buckets, SQS queues, and SNS
  topics**](https://hawkins.gitbook.io/consoleme/feature-videos/policy-management/policy-editor-for-iam-sqs-sns-and-s3)
  across hundreds of accounts in a single interface.

  Users can access most of your cloud resources in the AWS Console with a [**single
  click**](https://hawkins.gitbook.io/consoleme/feature-videos/policy-management/multi-account-policies-management). Cloud
  administrators can configure ConsoleMe to authenticate users through [**ALB
  Authentication**](https://hawkins.gitbook.io/consoleme/configuration/authentication-and-authorization/alb-auth),
  [**OIDC/OAuth2**](https://hawkins.gitbook.io/consoleme/configuration/authentication-and-authorization/oidc-oauth2-okta),
  or [**SAML**](https://hawkins.gitbook.io/consoleme/configuration/authentication-and-authorization/saml-auth0).

  … And more. Check out our [docs](https://hawkins.gitbook.io/consoleme/) to get started.



  - [Discord](https://discord.gg/nQVpNGGkYu)
  - [Docs](https://hawkins.gitbook.io/consoleme/)
  - [Weep (our CLI)](https://github.com/netflix/weep)
  - [Source Code](https://github.com/netflix/consoleme)
  - [Issue tracker](https://github.com/netflix/consoleme/issues)
  - [Blog Post](https://netflixtechblog.com/consoleme-a-central-control-plane-for-aws-permissions-and-access-fd09afdd60a8)
  - [ReInvent Talk](https://www.youtube.com/watch?v=fXNRYcNyw0c&t=5s)
  - [Anonymous Feedback Form](https://forms.gle/JVgmHVua3Tr7JVsr9)



  - [Achieving least-privilege at FollowAnalytics with Repokid, Aardvark and ConsoleMe](https://medium.com/followanalytics/granting-least-privileges-at-followanalytics-with-repokid-aardvark-and-consoleme-895d8daf604a)
  - [Netflix’s ConsoleMe local installation on Linux machine](https://kerneltalks.com/tools/netflixs-consoleme-local-installation-on-linux-machine/)
  - [Improving database security at FollowAnalytics with AWS IAM database authentication and ConsoleMe](https://medium.com/followanalytics/improving-database-security-at-followanalytics-with-aws-iam-database-authentication-and-consoleme-d00ea8a6edef)
  - [Awesome IAM Policy Tools](https://github.com/kdeldycke/awesome-iam#aws-policy-tools)
  - [Netflix on AWS Case Study](https://aws.amazon.com/solutions/case-studies/netflix/)
  - [Netflix Open Sources ConsoleMe to Manage Permissions and Access on AWS](infoq.com/news/2021/04/netflix-consoleme-aws/)



  - [AB180](https://www.ab180.co/en)
  - [Calm](https://www.calm.com/)
  - [FollowAnalytics](https://followanalytics.com/)
  - [myKaarma](https://mykaarma.com/)
  - [National Center for Biotechnology Information](https://www.ncbi.nlm.nih.gov/)
  - Feel free to submit a PR or let us know in an [Issue](https://github.com/Netflix/consoleme/issues) if you'd like to
    add your company to this list.


pkgId: 1dfb321ab904c9604168c3118872270de9a0e0d5e7acdb33d74c86a4d274f3b3
name: python-consolio
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A simple terminal I/O utility with spinner animation
url: https://github.com/devcoons/consolio
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consolio-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/consolio?style=for-the-badge)](https://pypi.org/project/consolio)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/consolio?style=for-the-badge)
  ![GitHub License](https://img.shields.io/github/license/devcoons/consolio?style=for-the-badge)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/consolio?style=for-the-badge&color=%23F0F)

  `Consolio` is a Python library that provides an elegant way to display progress updates, warnings, errors, and other status messages in the console with color-coded indicators and spinners. Ideal for CLI applications that require step-by-step feedback to users.



  - [Installation](#installation)
  - [Features](#features)
  - [Usage](#usage)
    - [Basic Initialization](#basic-initialization)
    - [Status Message Types](#status-message-types)
    - [Spinners](#spinners)
  - [Customization](#customization)



  Consolio does not require any dependencies outside of Python's standard library. To use it just install it using `pip install consolio`.



  - Color-coded messages for different statuses: Success, Error, Warning, and more.
  - Progress spinners in various styles (`dots`, `braille`, `default`).
  - Inline spinners for seamless progress tracking within a single line.
  - Thread-safe output for smooth and consistent console display.





  To get started, initialize `Consolio` with a desired spinner type. You can choose from `dots`, `braille`, or `default`.

  ```
  from consolio import Consolio

  console = Consolio(spinner_type='dots')  # Initialize with dots spinner
  ```



  Consolio supports multiple status messages, each with a unique color and symbol:

  - **Info**: `[!]` Blue - Marks the start of a process
  - **Work(Step)**: `[-]` Cyan - Intermediate step in a process
  - **Warning**: `[!]` Yellow - Displays warnings
  - **Error**: `[x]` Red - Displays errors
  - **Complete**: `[v]` Green - Indicates completion of a step or process

  Use the `print` method to print messages with a specific status, indentation level, and replacement option:

  ```
  console.print(indent=0, status="inf", text="Starting process")
  console.print(indent=1, status="wip", text="Executing step 1")
  console.print(indent=1, status="wrn", text="Warning: Check your input")
  console.print(indent=1, status="err", text="Error: Process failed")
  console.print(indent=0, status="cmp", text="Process complete")
  ```



  You can start a spinner to indicate an ongoing process using the `start_animate` method, then stop it using `stop_animate`.

  ```
  console.start_animate(indent=1)

  time.sleep(3)  # Simulating task duration
  console.stop_animate()
  ```

  Use the `inline_spinner=True` option to display the spinner on the same line as the last message:

  ```
  console.print(1, "stp", "Calculating size")
  console.start_animate(inline_spinner=True)
  time.sleep(2)
  console.stop_animate()
  ```


  The `Consolio` library supports a few customization options:

  - **Spinner Type**: Set `spinner_type` to `dots`, `braille`, or `default`.
  - **Indentation Level**: Control indentation level in messages for organized output.
  - **Inline Spinner**: Use `inline_spinner=True` to keep spinners on the same line as a message.
  - **Replacement Mode**: Set `replace=True` in `sprint` to overwrite the previous message line.

rpm_license:
  MIT License  Copyright (c) 2024 Ioannis D. (devcoons)  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.


pkgId: dba24e8b0ed0a660bf6aa5be6d92f9e51cd87f230bf6cc6ae803c19fba23fdd9
name: python-consonance
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: WhatsApp's handshake implementation using Noise Protocol
url: https://pypi.org/project/consonance/
rpm_license: GPL-3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consonance-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This library implements WhatsApp's handshake process which makes use of Noise Pipes with Curve25519, AES-GCM, and SHA256 from Noise Protocol


pkgId: 80ba859050b02233eb878ef40ab0cfb25bfd8e3c72d3f4de4cff864934f46918
name: python-constable
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: One decorator for lazy debugging. Inserts print statements directly into your AST.
url: https://github.com/saurabh0719/constable
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constable-0.3.1-1.src.rpm
checksum_type: sha256
description:
  constable allows you to monitor the state of specified variables at each assignment operation, providing a step-by-step view of variable changes!
  View the `Github repository <https://github.com/saurabh0719/constable>`__ and the `official docs <https://github.com/saurabh0719/constable#README>`__.
  How does it work?
  ~~~~~~~~~~~~~~~~~~
  The `constable.trace` decorator uses Python's Abstract Syntax Tree (AST) in much the same way we add `print`(s) to debug states. During runtime, it prepares and inserts `print` statements into the function's AST after every assignment operation (`ast.Assign`, `ast.AugAssign` and `ast.AnnAssign`), and then executes the modified code in a separate namespace with `exec`.
      $ pip install constable
  Tested for python 3.8 and above.
  Usage :
  ~~~~~~~~~~~~~
  Tracking variables in a function
      import constable
      @constable.trace('a', 'b')
      def example(a, b):
          a = a + b
          c = a
          a = "Experimenting with the AST"
          b = c + b
          a = c + b
          return a
      example(5, 6)
  Output :
      constable: example: line 5
          a = a + b
          a = 11
          type(a) = <class 'int'>
      constable: example: line 7
          a = "Experimenting with the AST"
          a = Experimenting with the AST
          type(a) = <class 'str'>
      constable: example: line 8
          b = c + b
          b = 17
          type(b) = <class 'int'>
      constable: example: line 9
          a = c + b
          a = 28
          type(a) = <class 'int'>
      constable: example: line 3 to 10
          args: (5, 6)
          kwargs: {}
          returned: 28
          execution time: 0.00018480 seconds
  Monitor functions
      import constable
      @constable.trace()
      def add(a, b):
          return a + b
      add(5, 6)
  Output :
      constable: add: line 3 to 5
          args: (5, 6)
          kwargs: {}
          returned: 11
          execution time: 0.00004312 seconds


pkgId: 38114cca88a77bafd3d27460c1088af9b50bf2820d45e39dc7bc5818b13c67a0
name: python-constallation-mmr
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: An OOP-heavy wrapper for the Mining Rig Rentals API
url: https://pypi.org/project/constallation-mmr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constallation-mmr-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/badge/PyPi-1.1.0-yellow?labelColor=blue&style=flat&logo=pypi&logoColor=yellow&link=https://pypi.org/project/constallation_mmr)](https://pypi.org/project/constallation_mmr)
  ![Python](https://img.shields.io/badge/Python-3.8-blue?labelColor=yellow&style=flat&logo=python)
  ![PyPI - Monthly](https://img.shields.io/pypi/dm/constallation_mmr)
  ![PyPI - Weekly](https://img.shields.io/pypi/dw/constallation_mmr)
  ![PyPI - Daily](https://img.shields.io/pypi/dd/constallation_mmr)


  Constallation-MMR is a OOP oriented API wrapper part of the greater constallation networking library.



  ```shell
  pip install constallation_mmr
  ```

  ```shell
  poetry add constallation_mmr
  ```


  - #### 1.0.0
    - added Rig class
    - added method `fetch_rigs`
  - #### 1.0.1
    - added method `fetch_rig`
  - #### 1.0.2
    - Added method inside class `Rig` for deleting the rig
    - Updated `Rig` class to support credential passthrough
  - #### 1.0.3
    - Rewrote `Rig` class properties to handle more verbose output
  - #### 1.0.4
    - Allowed `Rig` class ids to also be strings.


pkgId: 53cb56846eb2fb3dede6d20c7439896574cbbc3df49b468afec428c053b3d986
name: python-constantdict
arch: src
version: 2024.3
epoch: 0
release: 1
summary: An immutable dict class.
url: https://github.com/matthiasdiener/constantdict/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constantdict-2024.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/constantdict.svg)](https://badge.fury.io/py/constantdict)
  [![Doc Status](https://img.shields.io/github/actions/workflow/status/matthiasdiener/constantdict/doc.yaml?label=docs)](https://matthiasdiener.github.io/constantdict)
  [![License](https://img.shields.io/pypi/l/constantdict)](https://github.com/matthiasdiener/constantdict/blob/main/LICENSE)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/constantdict)](https://badge.fury.io/py/constantdict)



  An immutable dictionary class for Python, implemented as a thin layer around Python's builtin `dict` class. It is often [faster than other immutable dictionary implementations](https://matthiasdiener.github.io/constantdict/speed.html).



  Install this package with:
  ```
  $ pip install constantdict
  ```

  Usage example:
  ```python
  from constantdict import constantdict

  cd = constantdict({1: 2})


  assert cd == {1: 2}


  print(hash(cd), cd)


  try:
      
      cd[4] = 12
  except AttributeError:
      pass
  ```

  Please also see the [documentation](https://matthiasdiener.github.io/constantdict),
  as well as the examples in the `examples/` directory.






  - [immutabledict](https://github.com/corenting/immutabledict)
  - [immutables](https://github.com/MagicStack/immutables)
  - [pyrsistent](https://github.com/tobgu/pyrsistent)
  - [frozendict (old)](https://github.com/slezica/python-frozendict)
  - [frozendict (new)](https://github.com/Marco-Sulla/python-frozendict)




  - [PEP 416](https://www.python.org/dev/peps/pep-0416/)
  - [PEP 603](https://www.python.org/dev/peps/pep-0603/)



  MIT License.

rpm_license:
  MIT License  Copyright (c) 2024 University of Illinois Board of Trustees  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.


pkgId: 98c30a77f937e0a3b052b371df4fd79d037b25f5eb941e45c244f9658e158220
name: python-constantly
arch: src
version: 23.10.4
epoch: 0
release: 1
summary: Symbolic constants in Python
url: https://github.com/twisted/constantly
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constantly-23.10.4-1.src.rpm
checksum_type: sha256
description:
  A library that provides symbolic constant support.  It includes collections and
  constants with text, numeric, and bit flag values.  Originally
  ``twisted.python.constants`` from the `Twisted <https://twistedmatrix.com/>`_
  project.


pkgId: 23d8d3ac28750ddc1bb07dcbfad5679d23a3bcc46cbf34a5a193bed46d085f5a
name: python-constellate
arch: src
version: 0.8.21
epoch: 0
release: 1
summary: A bunch of utilities aggregated over time
url: https://pypi.org/project/constellate/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constellate-0.8.21-1.src.rpm
checksum_type: sha256
description:
      bash make.sh --setup-python-dev-envs
      bash make.sh --install-dependencies
      bash make.sh --install-tests-dependencies
  Usage
  *****


pkgId: 441093826eccef0ad27a0ae3d72eb2e439cd913ca0a3bd9aa3ea3c9174456744
name: python-constellation-vpc
arch: src
version: 0.5.0a4
epoch: 0
release: 1
summary: The VPC Module for constellation-aws
url: https://pypi.org/project/constellation-vpc/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constellation-vpc-0.5.0a4-1.src.rpm
checksum_type: sha256
description:
  **The version _0.5.0a4 is a package from the alpha stages and also pre-release** and has **undergone very minimal testing.** This version was built on `08/10/2024` Please use something more modern and closer to latest as this package is not secure for any actual use and its release serves archival means.

  ***

  - #### **<span style="color:red;">0.5.0a0</span>**
    - Added Peering Connection funcs to _vpc base class
    - Created `PeeringConnection` class
  - #### **<span style="color:red;">0.5.0a1</span>**
    - Write Peering Connection Docs
  - #### **<span style="color:red;">0.5.0a2</span>**
    - Added Internet Gateways into vpc.py
  - #### **<span style="color:red;">0.5.0a3</span>**
    - Added NAT Gateways into vpc.py
    - Added Peering Connections into vpc.py
  - #### **<span style="color:red;">0.5.0a4</span>**
    - Added ErrorHandling for Peering Connections


pkgId: cb7961eab97d75c8c81f85603a4e974f17a2c85b1ea082a546bb510dccc9a2d6
name: python-constellations
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Distributed multi-agent framework
url: https://github.com/pthomaid/constellations
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constellations-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Constellations

  A study in networks, agents and other things using Python.

  Implements a key-value store over a gossip protocol.

  Still an exercise in refactoring :/


pkgId: 7b0c4bf571909bec2b0dbcd72f5cbef9ef9f766843a3b3a11d9bf78e5a037f46
name: python-constrained_types
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Extensions for primitives to add validation constraints
url: https://github.com/meadsteve/constrained_types/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constrained_types-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Statement: Nothing should ever really be modelled as any String or any integer.



  A user wants to order a number of books. Can it be zero? Can it be negative?
  ```python
  @add_constraint(lambda x: x > 0, "Order must be at least 1")
  class OrderQuantity(ConstrainedInt):
      pass
  ```

  now:
  ```python
  quantity = OrderQuantity(5)


  total_price = quantity * 5


  quantity = OrderQuantity(-1)

  ```


  ```python
  @add_constraint(lambda x: x > 0, "Order must be at least 1")
  @add_constraint(lambda x: x < 200, "Our shipping system can't send more then 200")
  class OrderQuantity(ConstrainedInt):
      pass
  ```

  In addition the constraints are guaranteed to execute in order so any
  expensive checks to run can be listed further down.


  If you expect the same value multiple times you can add caching for
  the validation. The actual caching is passed to `functools.lru_cache`.

  ```python
  @add_constraint(lambda x: len(x) > 0, "The order id must be set")
  @add_constraint(lambda x: len(x) < 10, "Order ids are under 10 chars")
  @add_constraint(some_really_complicated_checksum, "The order number was invalid")
  @cache_constraint_results(maxsize=100)
  class OrderId(ConstrainedString):
      pass
  ```


  ```python

  def retrieve_order(order_id: OrderId):
      ...
  ```
  maybe something further down only accepts strings:

  ```python
  def _fetch_item_from_db(table_name: str, item_id: str):
      ...

  def retrieve_order(order_id: OrderId):
      
      return _fetch_item_from_db("orders", order_id)
  ```




  ```python
  @add_constraint(lambda x: x > 0, "Order must be at least 1")
  class OrderQuantity(ConstrainedInt):
      pass


  @add_constraint(lambda x: len(x) == 4, "Invalid order id")
  class BookId(ConstrainedString):
      pass


  class Order(BaseModel):
      book_quantity: OrderQuantity
      book_id: BookId
  ```


  The pydantic types only really work with pydantic. Invalid instances
  can be created by constructing directly. Since constraint checking
  is triggered by the constructor the constraints will *always* be
  true for any instance of the class.


pkgId: fb3e5a8459a81355d533bf05ec951d15c00c3057c0d16184d6f98069a68221e3
name: python-constrainedlr
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Constrained Linear Regression with sklearn-compatible API
url: https://github.com/tsitsimis/constrainedlr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constrainedlr-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/constrainedlr" target="_blank">
      <img src="https://img.shields.io/pypi/v/constrainedlr?color=%2334D058&label=pypi%20package" alt="Package version">
  </a>
  <a href="https://pypi.org/project/constrainedlr" target="_blank">
      <img src="https://img.shields.io/pypi/pyversions/constrainedlr.svg?color=%2334D058" alt="Supported Python versions">
  </a>

  constrainedlr is a drop-in replacement for `scikit-learn`'s `linear_model.LinearRegression` with the extended capability to apply constraints on the model's coefficients, such as signs and lower/upper bounds.


  ```bash
  pip install constrainedlr
  ```




  ```python
  from constrainedlr import ConstrainedLinearRegression

  model = ConstrainedLinearRegression()

  model.fit(
      X_train,
      y_train,
      coefficients_sign_constraints={0: "positive", 2: "negative"},
      intercept_sign_constraint="positive",
  )

  y_pred = model.predict(X_test)

  print(model.coef_, model.intercept_)
  ```


  ```python
  from constrainedlr import ConstrainedLinearRegression

  model = ConstrainedLinearRegression()

  model.fit(
      X_train,
      y_train,
      coefficients_range_constraints={
          0: {"lower": 2},  # 1st coefficient must be 2 or higher
          2: {"upper": 10},  # 3rd coefficient must be smaller than 10
          3: {"lower": 0.1, "upper": 0.5},  # 4th coefficient must be between 0.1 and 0.5
      },
  )

  y_pred = model.predict(X_test)

  print(model.coef_)
  ```

  See more in the [documentation](https://tsitsimis.github.io/constrainedlr/)



  MIT


pkgId: 71ec850f887bec03ae76d6a5fd3a1a7633e662d91a5adb754ecb3a4585213732
name: python-construct
arch: src
version: 2.10.70
epoch: 0
release: 1
summary: A powerful declarative symmetric parser/builder for binary data
url: http://construct.readthedocs.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-construct-2.10.70-1.src.rpm
checksum_type: sha256
description:
  Construct is a powerful **declarative** and **symmetrical** parser and builder for binary data.
  Instead of writing *imperative code* to parse a piece of data, you declaratively define a *data structure* that describes your data. As this data structure is not code, you can use it in one direction to *parse* data into Pythonic objects, and in the other direction, to *build* objects into binary data.
  The library provides both simple, atomic constructs (such as integers of various sizes), as well as composite ones which allow you form hierarchical and sequential structures of increasing complexity. Construct features **bit and byte granularity**, easy debugging and testing, an **easy-to-extend subclass system**, and lots of primitive constructs to make your work easier:
  * Fields: raw bytes or numerical types
  * Structs and Sequences: combine simpler constructs into more complex ones
  * Bitwise: splitting bytes into bit-grained fields
  * Adapters: change how data is represented
  * Arrays/Ranges: duplicate constructs
  * Meta-constructs: use the context (history) to compute the size of data
  * If/Switch: branch the computational path based on the context
  * On-demand (lazy) parsing: read and parse only what you require
  * Pointers: jump from here to there in the data stream
  * Tunneling: prefix data with a byte count or compress it


pkgId: a07ffc5fe9a4b36aeba982fc2f4240bae6510ff4a404fc2a3f6da65bd7b60731
name: python-construct-editor
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/timrid/construct-editor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-construct-editor-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  GUI (based on wxPython) for 'construct', which is a powerful declarative and symmetrical parser and builder for binary data.

description:
  This package provides a GUI (based on wxPython) for 'construct', which is a powerful declarative and symmetrical parser and builder for binary data. It can either be used standalone or embedded as a widget in another application.


  ![Preview](https://raw.githubusercontent.com/timrid/construct-editor/main/doc/preview.gif)


  Features:
  - show documentation as tooltip
  - different editors for:
      - Integer values
      - Enum values
      - FlagsEnum values
      - DateTime values
  - undo/redo in HexEditor and in ConstructEditor
  - extensible for custom constructs


  The preferred way to installation is via PyPI:
  ```
  pip install construct-editor
  ```


  To start the standalone version, just execute the following in the command line:
  ```
  construct-editor
  ```


  This is a simple example
  ```python
  import wx
  import construct as cs
  from construct_editor.wx_widgets import WxConstructHexEditor

  constr = cs.Struct(
      "a" / cs.Int16sb,
      "b" / cs.Int16sb,
  )
  b = bytes([0x12, 0x34, 0x56, 0x78])

  app = wx.App(False)
  frame = wx.Frame(None, title="Construct Hex Editor", size=(1000, 200))
  editor_panel = WxConstructHexEditor(frame, construct=constr, binary=b)
  editor_panel.construct_editor.expand_all()
  frame.Show(True)
  app.MainLoop()
  ```

  This snipped generates a GUI like this:

  ![Screenshot of the example](https://raw.githubusercontent.com/timrid/construct-editor/main/doc/example.png)




  This is the main widget ot this library. It offers a look at the raw binary data and also at the parsed structure.
  It offers a way to modify the raw binary data, which is then automaticly converted to the structed view. It also supports to modify the structed data and build the binary data from it.



  This is just the right side of the `ConstructHexEditor`, but can be used also used as standalone widget. It provides:
  - Viewing the structure of a construct (without binary data)
  - Parsing binary data according to the construct



  Just the left side of the `ConstructHexEditor`, but can be used also used as standalone widget. It provides:
  - Viewing Bytes in a Hexadecimal form
  - Callbacks when some value changed
  - Changeable format via `TableFormat`


pkgId: d373a79cde32b2c32220811699bf23a46d28b261f83e8d31a2c8822e84e764f5
name: python-construct-typing
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Extension for the python package 'construct' that adds typing features
url: https://github.com/timrid/construct-typing
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-construct-typing-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/construct-typing)](https://pypi.org/project/construct-typing/)
  ![PyPI - Implementation](https://img.shields.io/pypi/implementation/construct-typing)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/construct-typing)
  ![GitHub](https://img.shields.io/github/license/timrid/construct-typing)

  This project is an extension of the python package [*construct*](https://pypi.org/project/construct/), which is a powerful **declarative** and **symmetrical** parser and builder for binary data. This Repository consists of two packages:

  - **construct-stubs**: Adding .pyi for the whole *construct 2.10* package (according to  [PEP 561 stub-only packages](https://www.python.org/dev/peps/pep-0561/#stub-only-packages))
  - **construct_typed**: Adding additional classes that help with autocompletion and additional type hints.


  This package comply to [PEP 561](https://www.python.org/dev/peps/pep-0561/). So most of the static code analysers will recognise the stubs automatically. The installation only requires:
  ```
  pip install construct-typing
  ```


  The stubs are tested against the pytests of the *construct* package in a slightly modified form. Since the tests are relatively detailed I think most cases are covered.

  The new typed constructs have new written pytests, which also passes all pytests and the static type checkers.

  The following static type checkers are fully supported:
  - mypy
  - pyright



  The **construct-stubs** package is used for creating type hints for the orignial *construct* package. In particular the `build` and `parse` methods get type hints. So the core of the stubs  are the `TypeVar`'s `ParsedType` and `BuildTypes`:
  - `Construct.build`: converts an object of one of the types defined by `BuildTypes` to a `bytes` object.
  - `Construct.parse`: converts a `bytes` object to an object of type `ParsedType`.

  For each `Construct` the stub file defines to which type it parses to and from which it can be build. For example:

  | Construct            | parses to (ParsedType)         | builds from (BuildTypes)                 |
  | -------------------- | ------------------------------ | ---------------------------------------- |
  | `Int16ub`            | `int`                          | `int`                                    |
  | `Bytes`              | `bytes`                        | `bytes`, `bytearray` or `memoryview`     |
  | `Array(5, Int16ub)`  | `ListContainer[int]`           | `typing.List[int]`                       |
  | `Struct("i" / Byte)` | `Container[typing.Any]`        | `typing.Dict[str, typing.Any]` or `None` |

  The problem is to describe the more complex constructs like:
   - `Sequence`, `FocusedSeq` which has heterogenous subcons in comparison to an `Array` with only homogenous subcons.
   - `Struct`, `BitStruct`, `LazyStruct`, `Union` which has heterogenous and named subcons.

  Currently only the very unspecific type `typing.Any` can be used as type hint (maybe in the future it can be optimised a little, when [variadic generics](https://mail.python.org/archives/list/typing-sig@python.org/thread/SQVTQYWIOI4TIO7NNBTFFWFMSMS2TA4J/) become available). But the biggest disadvantage is that autocompletion for the named subcons is not available.

  Note: The stubs are based on *construct* in Version 2.10.



  **!!! EXPERIMENTAL VERSION !!!**

  To include autocompletion and further enhance the type hints for these complex constructs the **construct_typed** package is used as an extension to the original *construct* package. It is mainly a few Adapters with the focus on type hints.

  It implements the following new constructs:
  - `DataclassStruct`: similar to `construct.Struct` but strictly tied to `DataclassMixin` and `@dataclasses.dataclass`
  - `DataclassBitStruct`: similar to `construct.BitStruct` but strictly tied to `DataclassMixin` and `@dataclasses.dataclass`
  - `TEnum`: similar to `construct.Enum` but strictly tied to a `TEnumBase` class
  - `TFlagsEnum`: similar to `construct.FlagsEnum` but strictly tied to a `TFlagsEnumBase` class

  These types are strongly typed, which means that there is no difference between the `ParsedType` and the `BuildTypes`. So to build one of the constructs the correct type is enforced. The disadvantage is that the code will be a little bit longer, because you can not for example use a normal `dict` to build an `DataclassStruct`. But the big advantage is, that if you use the correct container type instead of a `dict`, the static code analyses can do its magic and find potential type errors and missing values without running the code itself.


  A short example:

  ```python
  import dataclasses
  import typing as t
  from construct import Array, Byte, Const, Int8ub, this
  from construct_typed import DataclassMixin, DataclassStruct, EnumBase, TEnum, csfield

  class Orientation(EnumBase):
      HORIZONTAL = 0
      VERTICAL = 1

  @dataclasses.dataclass
  class Image(DataclassMixin):
      signature: bytes = csfield(Const(b"BMP"))
      orientation: Orientation = csfield(TEnum(Int8ub, Orientation))
      width: int = csfield(Int8ub)
      height: int = csfield(Int8ub)
      pixels: t.List[int] = csfield(Array(this.width * this.height, Byte))

  format = DataclassStruct(Image)
  obj = Image(
      orientation=Orientation.VERTICAL,
      width=3,
      height=2,
      pixels=[7, 8, 9, 11, 12, 13],
  )
  print(format.build(obj))
  print(format.parse(b"BMP\x01\x03\x02\x07\x08\t\x0b\x0c\r"))
  ```
  Output:
  ```
  b'BMP\x01\x03\x02\x07\x08\t\x0b\x0c\r'
  Image:
      signature = b'BMP' (total 3)
      orientation = Orientation.VERTICAL
      width = 3
      height = 2
      pixels = ListContainer:
          7
          8
          9
          11
          12
          13
  ```


pkgId: 0bea9a0fdb560f2579dbfe89ac1d05d7d54a00fa8844f508416641ec74864515
name: python-constructive-geometries
arch: src
version: 1.0
epoch: 0
release: 1
summary: Simple tools to define world locations from a set of topological faces and set algebra
url: https://pypi.org/project/constructive-geometries/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constructive-geometries-1.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/constructive-geometries/badge/?version=latest)](http://constructive-geometries.readthedocs.io/?badge=latest) [![Build Status](https://travis-ci.org/cmutel/constructive_geometries.svg?branch=master)](https://travis-ci.org/cmutel/constructive_geometries) [![Coverage Status](https://coveralls.io/repos/github/cmutel/constructive_geometries/badge.svg?branch=master)](https://coveralls.io/github/cmutel/constructive_geometries?branch=master)

  Simple tools to define world locations from a set of topological faces and set algebra. For example, one could define a "rest of the world" which started from all countries, but excluded every country who name started with the letter "a".

  [Documentation](http://constructive-geometries.readthedocs.io/?badge=latest) and [usage example](https://github.com/cmutel/constructive_geometries/blob/master/examples/Geomatching.ipynb).

  Builds on top of [constructive geometries](https://github.com/cmutel/constructive_geometries).

  Basic installation needs [wrapt](http://wrapt.readthedocs.io/en/latest/) and [country_converter](https://github.com/konstantinstadler/country_converter); GIS functions need [shapely](https://github.com/Toblerity/Shapely), and [fiona](https://github.com/Toblerity/Fiona).


pkgId: 8ba62e5289b1b6fd47edb6d4ea0bc6dc1362bcc3ec9f729b0993ce0ebbdcee62
name: python-constructor-io
arch: src
version: 1.8.5
epoch: 0
release: 1
summary: Constructor.IO Python Client
url: https://www.constructor.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constructor-io-1.8.5-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/constructor-io.svg)](https://pypi.python.org/pypi/constructor-io)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

  A Python client for [Constructor.io](http://constructor.io/). [Constructor.io](http://constructor.io/) provides search as a service that optimizes results using artificial intelligence (including natural language processing, re-ranking to optimize for conversions, and user personalization).


  Full API documentation is available on [Github Pages](https://constructor-io.github.io/constructorio-python)



  Requesting results from your back-end can be useful in order to control result rendering logic on your server, or augment/hydrate results with data from another system. However, a back-end integration has additional requirements compared to a front-end integration. Please review the [Additional Information For Backend Integrations](https://github.com/Constructor-io/constructorio-python/wiki/Additional-Information-for-Backend-Integrations) article within the wiki for more detail.



  ```
  pip install constructor-io
  ```



  You can find this in your [Constructor.io dashboard](https://constructor.io/dashboard). Contact sales if you'd like to sign up, or support if you believe your company already has an account.



  Once imported, an instance of the client can be created as follows:

  ```python
  from constructor_io.constructor_io import ConstructorIO

  constructorio = ConstructorIO({
      "api_key": "YOUR API KEY",
  })
  ```



  After instantiating an instance of the client, four modules will be exposed as properties to help retrieve data from Constructor.io: `search`, `browse`, `autocomplete`, and `recommendations`.



  ```bash
  make install                            # install dependencies
  pipenv run pylint constructor_io  # run lint
  pipenv run pytest .                     # run tests with coverage report
  make docs                               # output documentation to `./docs` directory
  ```


pkgId: 4024471204cdcaba33eabf64b90e92dd9ed4116ed671c83b544cc09407ece459
name: python-constructs
arch: src
version: 10.3.0
epoch: 0
release: 1
summary: A programming model for software-defined state
url: https://github.com/aws/constructs
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-constructs-10.3.0-1.src.rpm
checksum_type: sha256
description:
  > Software-defined persistent state

  ![Release](https://github.com/aws/constructs/workflows/Release/badge.svg)
  [![npm version](https://badge.fury.io/js/constructs.svg)](https://badge.fury.io/js/constructs)
  [![PyPI version](https://badge.fury.io/py/constructs.svg)](https://badge.fury.io/py/constructs)
  [![NuGet version](https://badge.fury.io/nu/Constructs.svg)](https://badge.fury.io/nu/Constructs)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/software.constructs/constructs/badge.svg?style=plastic)](https://maven-badges.herokuapp.com/maven-central/software.constructs/constructs)



  Constructs are classes which define a "piece of system state". Constructs can be composed together to form higher-level building blocks which represent more complex state.

  Constructs are often used to represent the *desired state* of cloud applications. For example, in the AWS CDK, which is used to define the desired state for AWS infrastructure using CloudFormation, the lowest-level construct represents a *resource definition* in a CloudFormation template. These resources are composed to represent higher-level logical units of a cloud application, etc.



  This project has adopted the [Amazon Open Source Code of
  Conduct](https://aws.github.io/code-of-conduct).

  We welcome community contributions and pull requests. See our [contribution
  guide](./CONTRIBUTING.md) for more information on how to report issues, set up a
  development environment and submit code.



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).


pkgId: 63ed97acb6b605818411085fc777361b8388464c41652fcbf0efb64a6524748e
name: python-construe
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An LLM inferencing benchmark tool focusing on device-specific latency and memory usage
url: https://pypi.org/project/construe/
rpm_license: BSD 3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-construe-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **An LLM inferencing benchmark tool focusing on device-specific latency and memory usage.**



  This package is intended to be installed with `pip` and it will create a command line program `construe` on your `$PATH` to execute benchmarking comamnds:

  ```
  $ pip install construe
  $ which construe
  $ construe --help
  ```

  There are several top-level configurations that you can specify either as an environment variable or a command line option before the command. The environment variables are as follows:

  - `$CONSTRUE_ENV` or `$ENV`: specify the name of the experimental environment for comparison purposes.
  - `$CONSTRUE_DEVICE` or `$TORCH_DEVICE`: specify the name of the default device to use with PyTorch e.g. cpu, mps, or cuda.

  The command line utility help is as follows:

  ```
  Usage: construe [OPTIONS] COMMAND [ARGS]...

  Options:
    --version          Show the version and exit.
    -d, --device TEXT  specify the pytorch device to run on e.g. cpu, mps or
                       cuda
    -e, --env TEXT     name of the experimental environment for comparison
                       (default is hostname)
    -h, --help         Show this message and exit.

  Commands:
    basic
    moondream
  ```



  The basic benchmarks implement dot product benchmarks from the [PyTorch documentation](https://pytorch.org/tutorials/recipes/recipes/benchmark.html). These benchmarks can be run using `construe basic`; for example by running:

  ```
  $ construe -e "MacBook Pro 2022 M1" basic -o results-macbook.pickle
  ```

  The `-e` flag specifies the environment for comparison purposes and the `-o` flag saves the measurements out to disk as a Pickle file that can be loaded for comparison to other environments later.

  Command usage is as follows:

  ```
  Usage: construe basic [OPTIONS]

  Options:
    -e, --env TEXT             name of the experimental environment for
                               comparison (default is hostname)
    -o, --saveto TEXT          path to write the measurements pickle data to
    -t, --num-threads INTEGER  specify number of threads for benchmark (default
                               to maximum)
    -F, --fuzz / --no-fuzz     fuzz the tensor sizes of the inputs to the
                               benchmark
    -S, --seed INTEGER         set the random seed for random generation
    -h, --help                 Show this message and exit.
  ```



  The [moondream](https://huggingface.co/vikhyatk/moondream2) package contains small image-to-text computer vision models that can be used in the first step of a [content moderation](https://www.cloudraft.io/blog/content-moderation-using-llamaindex-and-llm) workflow (e.g. image to text, moderate text). This benchmark executes the model for _encoding_ and _inferencing_ on a small number of images and reports the average time for both operations and the line-by-line memory usage of the model.

  It can be run as follows:

  ```
  $ construe moondream
  ```

  Command usage is as follows:

  ```
  Usage: construe moondream [OPTIONS]

  Options:
    -h, --help  Show this message and exit.
  ```



  To release the construe library and deploy to PyPI run the following commands:

  ```
  $ python -m build
  $ twine upload dist/*
  ```


pkgId: d1b3db99c3270e9a7fb8a893bca9a2e0b949ed04f27d920d8d8f07ad2b758316
name: python-consulate
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A Client library for the Consul
url: https://consulate.readthedocs.org
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-consulate-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Consulate is a Python client library and set of application for the Consul
  service discovery and configuration system.
  |Version| |Downloads| |Status| |Coverage| |License|


pkgId: 320a90b602be6a288df5c7b9f0adbe36fd14884fe6655a77466b846bfbb71530
name: python-contablo
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Configurable Table Loader package for python
url: https://github.com/gandy92/contablo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contablo-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


  **ConTabLo** is a python package providing a **Con**figurable **Tab**le **Lo**ader.

  With ConTabLo, it is possible to define import configurations for a number of different CSV file formats with the goal to import them into a defined table format, with defined data types for each column. Given a number of configurations, each CSV file can be matched to its configuration via meta data like delimiter, file format and column headers.

  A CLI tool is provided that can automatically generate configuration files templates from a number of CSV files. These templates can be edited to get a working configuration. Additionally, a json-schema can created from a configuration file to support editing the configurations.


  ConTabLo can be installed from the [Python Package Index](https://pypi.org/):
  ```shell
  python3 -m pip install contablo
  ```


  Used as a command line tool, ConTabLo provides the following functionality:
  ```shell
  $ contablo -h
  Usage: contablo [OPTIONS] COMMAND [ARGS]...

    CLI tool to the ConTabLo python package.

  Options:
    -v, --verbose
    -h, --help     Show this message and exit.

  Commands:
    convert         Load the given CSV file(s) based on their...
    mk-import-tmpl  Create an input configuration template for the given...
    mk-schema       Create a JSON schema for validation of JSON based...
  ```




  Any application that uses ConTabLo would probably have a good idea on the composition of the table, data should be imported into.
  This idea can be expressed by creating a list of FieldSpec objects (or rather objects of classes that follow the FieldSpec protocol). Since the commandlinetool ```contablo``` is rather generic, it provides a way to initialize this table specification from a simple JSON file like the following:
  ```JSON
  [
      { "name": "date", "type": "date", "help": "Date of payment" },
      { "name": "payee","type": "string", "help": "Person or institution sending or receiving the payment" },
      { "name": "note", "type": "string", "help": "Transaction notes" },
      { "name": "iban", "type": "string", "help": "Payee IBAN" },
      { "name": "bic", "type": "string", "help": "Payee BIC, if applicable" },
      { "name": "amount", "type": "number", "help": "Payment amount" },
      { "name": "balance", "type": "number", "help": "New account balance" }
  ]
  ```

  With this, we can create an import template from a number of CSV files that already contains hints for possible target fields:
  ```shell
  $ contablo mk-import-tmpl -t fieldspec-banking.json banking*.csv -o bank-tmpl
  Found 1 distict file formats:
    
         
              Datum;Name;Text;Betrag (EUR);Saldo (EUR)
              30.10.2024;"Some random payee Inc.";"SEPA-Basislasts [..] 24 Kunden-Referenz: xxxyyyzzz";"-217,50";"539,11"
    Template was written to bank-tmpl-20241103_165348-01.json
  ```

  The resulting template now contains specifications for each of the five columns, e.g.:

  ```JSON
  {
    "columns": [
      {
        "label": "Datum",
        "field": "date",
        "format": "dd.mm.yyyy"
      },
      {
        "label": "Name",
        "field": "payee|note|iban|bic",
        "format": "",
        "samples": [
          "Some random payee Inc.",
          "Another random payee Inc.",
          "Someone completely different"
        ]
      },
      {
        "label": "Text",
        "field": "payee|note|iban|bic",
        "format": "",
        "samples": [
          "Note 1",
          "Note 2"
        ]
      },
      {
        "label": "Betrag (EUR)",
        "field": "amount|balance",
        "format": "-1.000,00"
      },
      {
        "label": "Saldo (EUR)",
        "field": "amount|balance",
        "format": "1.000,00"
      }
    ]
  }
  ```
  Each "field" entry contains suggestions for target fields to choose from, depending on the type of input (again, see subclasses of FieldSpec for builtin types).

  The same template after a manual cleaup results in an import specification:
  ```JSON
  {
    "columns": [
      {
        "label": "Datum",
        "field": "date",
        "format": "dd.mm.yyyy"
      },
      {
        "label": "Name",
        "field": "payee"
      },
      {
        "label": "Text",
        "field": "note"
      },
      {
        "label": "Betrag (EUR)",
        "field": "amount",
        "format": "-1.000,00"
      },
      {
        "label": "Saldo (EUR)",
        "field": "balance",
        "format": "1.000,00"
      }
    ]
  }
  ```
  Note, how the sample and empty format elements were removed and the field entries were reduced to the desired target field name. The labels must stay unchanged, they are an essential identification marker matching a CSV import file to the appropriate import configuration. Since it is no longer a template, we rename it to a more appropriate name, e.g. ```bank-import-config.json```.

  We are now ready to convert the type of CSV files described by the import specification:
  ```shell
  $ contablo convert -t fieldspec-banking.json -c bank-import-config.json banking-*.csv -o merged_data.csv
  ```


  If you want to contribute to this project, please use the following steps:

  1. Fork the project.
  2. Create a new branch (git checkout -b feature/awesome-feature).
  3. Commit your changes (git commit -m 'Add some feature').
  4. Push to the branch (git push origin feature/awesome-feature).
  5. Open a pull request.



  This projects aims to follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/#summary) guidelines.

  When writing commit messages, use one of the following categories to clearly describe the purpose of your commit:

  - **feat** / **feature**: ✨  Introducing new features
  - **fix** / **bugfix**: 🐛  Addressing bug fixes
  - **perf**: 🚀  Enhancing performance
  - **refactor**: 🔄  Refactoring code - **Not displayed in CHANGELOG**
  - **test** / **tests**: ✅  Adding or updating tests - **Not displayed in CHANGELOG**
  - **build** / **ci**: 🛠️  Build system or CI/CD updates - **Not displayed in CHANGELOG**
  - **doc** / **docs**: 📚  Documentation changes - **Not displayed in CHANGELOG**
  - **style**: 🎨  Code style or formatting changes - **Not displayed in CHANGELOG**
  - **chore**: 🔧  Miscellaneous chores
  - **other**: 🌟  Other significant changes



  - `feat: Add cool new feature`
  - `fix: Resolve unexpected behavior with translation`


  This project is licensed under the MIT License.


pkgId: 919d6718303e5596f2b695ec8130dc477d43eaf0625ed63e02a14bb2655b05c5
name: python-contact
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Saves the contact and fetches the name on entering number
url: https://github.com/baggageai/fraudcop
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contact-1.0.5-1.src.rpm
checksum_type: sha256
description:
  It takes contact list and saves in the database or on entering the number returns the name if the number is found in the database.


  ```pip install contact```


  Open terminal and type contact and then input the integer of your choice



  Â© 2022 Abhishek Pandey

  This repository is licensed under the MIT license. See LICENSE for details.


pkgId: b4522e02377cf16dc335e3b8a05e9f3fab937280b27aefc65ab0126655d82cb2
name: python-container-collection
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Collection of tasks for running containerized models.
url: https://pypi.org/project/container-collection/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-container-collection-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://bagherilab.github.io/container-collection/_badges/build.svg)](https://github.com/bagherilab/container-collection/actions?query=workflow%3Abuild)
  [![Lint status](https://bagherilab.github.io/container-collection/_badges/lint.svg)](https://github.com/bagherilab/container-collection/actions?query=workflow%3Alint)
  [![Documentation](https://bagherilab.github.io/container-collection/_badges/documentation.svg)](https://bagherilab.github.io/container-collection/)
  [![Coverage](https://bagherilab.github.io/container-collection/_badges/coverage.svg)](https://bagherilab.github.io/container-collection/_coverage/)
  [![Code style](https://bagherilab.github.io/container-collection/_badges/style.svg)](https://github.com/psf/black)
  [![Version](https://bagherilab.github.io/container-collection/_badges/version.svg)](https://pypi.org/project/container-collection/)
  [![License](https://bagherilab.github.io/container-collection/_badges/license.svg)](https://github.com/bagherilab/container-collection/blob/main/LICENSE)

  Collection of tasks for running containerized models.
  Designed to be used both in [Prefect](https://docs.prefect.io/latest/) workflows and as modular, useful pieces of code.



  The collection can be installed using:

  ```bash
  pip install container-collection
  ```

  We recommend using [Poetry](https://python-poetry.org/) to manage and install dependencies.
  To install into your Poetry project, use:

  ```bash
  poetry add container-collection
  ```





  All tasks in this collection are wrapped in a Prefect `@task` decorator, and can be used directly in a Prefect `@flow`.
  Running tasks within a [Prefect](https://docs.prefect.io/latest/) flow enables you to take advantage of features such as automatically retrying failed tasks, monitoring workflow states, running tasks concurrently, deploying and scheduling flows, and more.

  ```python
  from prefect import flow
  from container_collection.<module_name> import <task_name>

  @flow
  def run_flow():
      <task_name>()

  if __name__ == "__main__":
      run_flow()
  ```

  See [cell-abm-pipeline](https://github.com/allen-cell-animated/cell-abm-pipeline) for examples of using tasks from different collections to build a pipeline for simulating and analyzing agent-based model data.



  Not all use cases require a full workflow.
  Tasks in this collection can be used without the Prefect `@task` decorator by simply importing directly from the module:

  ```python
  from container_collection.<module_name>.<task_name> import <task_name>

  def main():
      <task_name>()

  if __name__ == "__main__":
      main()
  ```

  or using the `.fn()` method:

  ```python
  from container_collection.<module_name> import <task_name>

  def main():
      <task_name>.fn()

  if __name__ == "__main__":
      main()
  ```


pkgId: fdc916994aab2668d5d2b2bb56838cc9f66b25dee46a00397d9104f410ada5cd
name: python-container-inspector
arch: src
version: 33.0.0
epoch: 0
release: 1
url: https://github.com/nexB/container-inspector
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-container-inspector-33.0.0-1.src.rpm
checksum_type: sha256
summary:
  Docker, containers, rootfs and virtual machine related software composition analysis (SCA) utilities.


pkgId: 5ae297c77e92710d4dc8a78b486e29de0f870253ca8b6b768744ab7478a4d148
name: python-container-runtime-interface-api
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python library for interaction with the Kubernetes container runtime interface API.
url: https://github.com/dominodatalab/container-runtime-interface-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-container-runtime-interface-api-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Python library for communication with the Kubernetes [Container Runtime Interface API](https://github.com/kubernetes/cri-api).



  Install `container-runtime-interface-api` with `pipenv` or `pip`:

  ```shell
  $ pipenv install container-runtime-interface-api
  Adding container-runtime-interface-api to Pipfile's [packages]…
  ✔ Installation Succeeded
  ...
  ```

  This project currently supports Python 3.7+.



  Connection to the CRI API is generally done through a UNIX socket, but any gRPC address supported by [insecure_channel](https://grpc.github.io/grpc/python/grpc.html#grpc.insecure_channel) will work.

  ```python
  from cri_api.channel import Channel
  channel = Channel.from_env() # Loads from RUNTIME_SOCK
  channel = Channel("unix:///var/run/dockershim.sock") # Explicit argument
  ```



  The `Images` class is a thin wrapper around the existing ImageService API:

  ```python
  from cri_api.images import Images

  channel = Channel.from_env()
  images = Images(channel)

  images.list_images()
  images.pull_image("busybox")

  busybox_images = [i["id"] for i in images.list_images() if any("busybox" in r for r in i["repoTags"])]
  [images.remove_image(i) for i in busybox_images]
  ```



  The `Containers` class is a thin wrapper around the existing RuntimeService API:

  ```python
  from cri_api.images import Images
  from cri_api import ContainerFilter, ContainerState, ContainerStateValue

  channel = Channel.from_env()
  images = Containers(channel)

  containers.list_containers()
  containers.list_containers(ContainerFilter(state=ContainerStateValue(state=ContainerState.CONTAINER_EXITED)))

  containers.get_container("9d81052cc027a1fb2ec61b898ea0fd6fc88216ce730ad75f4c52b29849cb440f")
  ```



  Raw access to the underlying CRI API objects can be done by importing from `cri_api`:

  ```python
  from os import getenv
  from grpc import insecure_channel
  from cri_api import RuntimeServiceStub, ListContainersRequest

  stub = RuntimeServiceStub(insecure_channel(getenv("RUNTIME_SOCK")))
  response = stub.ListContainers(ListContainersRequest())
  containers = response.containers
  ```



  ```shell
  $ bin/update-proto.sh
  ```

  Commit & create a new pull request!



  Interactive development on MacOS can be done by leveraging [minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/):

  ```shell
  $ minikube start --container-runtime=cri-o
  $ minikube ssh
  $ socat -d -d TCP4-LISTEN:15432,fork UNIX-CONNECT:/var/run/crio/crio.sock


  $ export RUNTIME_SOCK=$(minikube ip):15432
  ...
  ```



  Unit tests are run against all supported Python versions: 3.7, 3.8, and 3.9.

  A basic set of integration tests is included alongside the unit tests, but are only run if the `RUNTIME_SOCK` environment variable is set correctly.
  They are verified in CI against a minikube installation running Docker and `dockershim`.

  Run unit tests with:

  ```shell
  $ pytest
  ```


pkgId: e18e930e477196b106d56e52d00ae42b52b3d4a16d6d389e2d1f12d3cb516266
name: python-container-service-extension
arch: src
version: 3.1.4
epoch: 0
release: 1
summary: Container Service Extension for vCloud Director
url: https://github.com/vmware/container-service-extension
rpm_license: BSD-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-container-service-extension-3.1.4-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/container-service-extension.svg)](https://pypi.python.org/pypi/container-service-extension) [![Stable Version](https://img.shields.io/pypi/v/container-service-extension.svg)](https://pypi.python.org/pypi/container-service-extension) [![Join the chat at https://gitter.im/container-service-extension/Lobby](https://badges.gitter.im/container-service-extension/Lobby.svg)](https://gitter.im/container-service-extension/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Build Status](https://img.shields.io/travis/vmware/container-service-extension.svg?style=flat)](https://travis-ci.org/vmware/container-service-extension/)

  **container-service-extension** is a vCloud Director extension that manages the life cycle of Kubernetes clusters for tenants.

  This extension is designed to be installed on a vCloud Director instance by the service provider (system administrator).

  **container-service-extension** is distributed as a Python package.



  See our [site](https://vmware.github.io/container-service-extension/).



  The *container-service-extension* project team welcomes contributions from the community. Before you start working with *container-service-extension*, please read our [Developer Certificate of Origin](https://cla.vmware.com/dco). All contributions to this repository must be signed as described on that page. Your signature certifies that you wrote the patch or have the right to pass it on as an open-source patch. For more detailed information, refer to [CONTRIBUTING.md](docs/CONTRIBUTING.md).



  [BSD-2](LICENSE.txt)


pkgId: e57b6ac6196507747d56f9236fcf92f731008cf3030e618205deafca9a815911
name: python-container-workflow-tool
arch: src
version: 1.5.10
epoch: 0
release: 1
summary: A python3 tool to make rebuilding images easier by automating several steps of the process.
url: https://github.com/sclorg/container-workflow-tool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-container-workflow-tool-1.5.10-1.src.rpm
checksum_type: sha256
description:
  [![Docker Repository on Quay](https://quay.io/repository/rhscl/cwt-generator/status "Docker Repository on Quay")](https://quay.io/repository/rhscl/cwt-generator)
  A python3 tool to make rebuilding container images easier by automating several steps of the process.


pkgId: 7deeb69d8ca4c714e36d98a2e6d9661839dc8a733ff7e84bbefef5a498e33a6d
name: python-containerd
arch: src
version: 1.5.3
epoch: 0
release: 1
summary: containerd API for Python
url: https://github.com/siemens/pycontainerd
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-containerd-1.5.3-1.src.rpm
checksum_type: sha256
description:
  This repository provides a Python3 API to [containerd's](https://containerd.io)
  (gRPC) API, directly generated from the [original containerd `.proto` API
  definitions](https://github.com/containerd/containerd/tree/master/api). As it is
  generated from the protocol files, this Python package does not aim to be a
  fully Pythonesque package. In consequence, the usual idiosyncrasies of gRPC and
  protoc shine through.

  > **Note:** with Python2 going end-of-life in January 2020 we don't support
  > Python2 in this package at this very late time in the lifecycle.



  The versioning of this package complies with [PEP
  440](https://www.python.org/dev/peps/pep-0440/).

  The version is composed of the version of the supported containerd API (e.g. 1.2
  or 1.3) and an incremental number for each pycontainerd release for that
  specific containerd API version (starting from 0) connected with a '.' (a dot).

  Ideally the Python containerd API has to be generated only once per containerd
  API version, resulting in x.y.0 package versions.

  The result is version numbers like:

  - 1.2.1 for the second release for API 1.2
  - 1.3.0 for the first release for API 1.3



  This project is licensed as [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0) (SPDX-License-Identifier: Apache-2.0).

  You can obtain the full license text from the file `License` of this repository.



  Installation depends on your starting point:

  1. You get the packages from https://pypi.org/project/containerd
  2. You have a `pycontainerd` Python Wheel package (something like
     `containerd-x.y.z-py3-none-any.whl`).
  3. You only have the source code (the result of cloning the git repository).



  Python3 PIP is needed for Wheel installations (either from a ready Wheel package
  or from a self-built package). PIP takes care of installing all the Python
  packages listed as dependencies. Runtime dependencies are nevertheless listed
  below.



  Simply let PIP install the latest release for the corresponding containerd API version.

  For example, for the container API version 1.5:

  ```
  sudo pip3 install "containerd==1.5.*"
  ```

  The quotes are important to avoid that the shell tries to resolve the "*" and passes it untouched to PIP.



  Go to the directory where the wheel package is available and run:

  ```bash
  sudo pip3 install containerd-<x.y.z>-py3-none-any.whl
  ```

  Being `containerd-<x.y.z>-py3-none-any.whl` the filename of the wheel package.

  > *NOTE*: a global installation is required (or rather, more convenient) because
  the `containerd` API socket is usually only reachable for `root`.



  Additionally, if building from source code you'll also need `make`.

  A Makefile is being provided that takes care of

  1. Building the Wheel package
  2. Installing the Wheel package

  Get into the directory corresponding the API version of your containerd installation and run following:

  ```bash
  make install
  ```

  The second step is under the hood simply running the installation of the wheel
  package explained above. Including the global installation, therefore a `sudo`
  execution is asking for the user's password (assuming the user has that right).



  The resulting Wheel package provides following Python packages (they have to be
  imported individually), providing multiple modules:

  - containerd.events
  - containerd.services.containers.v1
  - containerd.services.content.v1
  - containerd.services.diff.v1
  - containerd.services.events.v1
  - containerd.services.images.v1
  - containerd.services.introspection.v1
  - containerd.services.leases.v1
  - containerd.services.namespaces.v1
  - containerd.services.snapshots.v1
  - containerd.services.tasks.v1
  - containerd.services.version.v1
  - containerd.types
  - containerd.types.tasks
  - containerd.protobuf (_note: this is not a protobuf alias_)
  - containerd.vendor.gogoproto

  In order to get the modules being provided by a package you can run:

  ```bash
  python3 -c 'import <package> ; help(<package>)'
  ```

  For example, for `containerd.events`:

  ```bash
  python3 -c 'import containerd.events ; help(containerd.events)'
  ```





  The following simple example queries containerd for its list of available
  containerd namespaces. Make sure you have the necessary privileges to connect to
  containerd; you may need to run this script as root:

  ```python
  import grpc
  from containerd.services.namespaces.v1 import namespace_pb2_grpc, namespace_pb2

  with grpc.insecure_channel('unix:///run/containerd/containerd.sock') as channel:
      namespacev1 = namespace_pb2_grpc.NamespacesStub(channel)
      namespaces = namespacev1.List(namespace_pb2.ListNamespacesRequest()).namespaces
      for namespace in namespaces:
          print('namespace:', namespace.name)
  ```

  Usually, you want to add proper error handling. This is just a very simplistic
  example to illustrate the principle.



  Several of containerd's APIs are namespaced. That is, they work only on a single
  namespace at a time. The namespace applies on the level of individual service
  calls and needs to be specified as an (additional) metadata element to these
  calls. If not specified, it the namespace will default to the namespace named
  `default`. The following example lists all containers in the `"moby"` namespace;
  this is the containerd namespace used by Docker.

  ```python
  import grpc
  from containerd.services.containers.v1 import containers_pb2_grpc, containers_pb2

  with grpc.insecure_channel('unix:///run/containerd/containerd.sock') as channel:
      containersv1 = containers_pb2_grpc.ContainersStub(channel)
      containers = containersv1.List(
          containers_pb2.ListContainersRequest(),
          metadata=(('containerd-namespace', 'moby'),)).containers
      for container in containers:
          print('container ID:', container.id)
  ```



  Containerd events can be easily read from the endless event stream via the
  `containerd.services.events.v1` API, using the `Subscribe` service. The
  following example subscribes to all events and then prints their type and
  contents as the events come:

  ```python
  import grpc

  from containerd.services.events.v1 import unwrap, events_pb2, events_pb2_grpc
  from google.protobuf import any_pb2

  with grpc.insecure_channel('unix:///run/containerd/containerd.sock') as channel:
      print("waiting for containerd events...")
      eventsv1 = events_pb2_grpc.EventsStub(channel)
      for ev in eventsv1.Subscribe(events_pb2.SubscribeRequest()):
          print('event type: ', ev.event.type_url)
          print('value: ', unwrap(ev))
  ```

  > **Note:** `containerd.services.events.v1.unwrap(envelope)` is a convenience
  > function which unwraps the event object inside an event envelope returned by
  > `Subscribe()`: the unwrapped event object is returned as a Python object of
  > sub class `containerd.events.*` (as opposed to the arbitrary "any" binary
  > value inside the event envelope).



  To help containerd client developers getting started, we've included two simple
  examples which are also made available as the CLI programs `lsctr` and
  `watchctr` (source code in `examples/`) when cloning the repository.

  You first have to install the wheel package for the `containerd` package.

  - `lsctr` lists all containerd containers in all namespaces. It is basically
    kind of an all-in-one combination of the `ctr` commands for namespaces,
    containers, and tasks in a single command.
  - `watchctr` watches containerd events, such as container creation, start, stop,
    et cetera, and then prints them to the terminal.

  To check that it works, run the `lsctr` command: this should list all available
  containerd containers, across all containerd namespaces (remember to use `sudo`
  in case you don't have the necessary privileges as an ordinary user to talk to
  containerd):

  ```bash
  sudo lsctr
  ```

  This should spit out something like this, when running on a recent Docker CE
  installation, which uses containerd under the hood:

  ```txt
  moby
    ⤏ labels (0):
    ▩ container: 0eeb9e2862e9f68e832a2e2c60a2e44e74d54b05266532cf19b112f4d959e3fb
      ▷ PID: 3359 ⚐ status: RUNNING
      ⚙ runtime: io.containerd.runtime.v1.linux
      ⤏ labels (1):
          "com.docker/engine.bundle.path": "/var/run/docker/containerd/0eeb9e2862e9f68e832a2e2c60a2e44e74d54b05266532cf19b112f4d959e3fb"
      ◷ created: 2019-09-04 07:24:32.646856 ◷ updated: 2019-09-04 07:24:32.646856
    ▩ container: 1663afd0ddc6e0bba30b7fcc27b26044ece6022d970e32731db5dcb807b168df
      ▷ PID: 66062 ⚐ status: RUNNING
      ⚙ runtime: io.containerd.runtime.v1.linux
      ⤏ labels (1):
          "com.docker/engine.bundle.path": "/var/run/docker/containerd/1663afd0ddc6e0bba30b7fcc27b26044ece6022d970e32731db5dcb807b168df"
      ◷ created: 2019-08-16 08:08:21.471493 ◷ updated: 2019-08-16 08:08:21.471493
  ...
  ```

  You can use `lsctr -h` to see the few CLI options available.



  The following Python packages are required:

  - [`grpcio`](https://pypi.org/project/grpcio/) – gRPC for Python; required in
    order to communicate with containerd. This is a runtime dependency.
  - [`protobuf`](https://pypi.org/project/protobuf/) – protobuf for Python;
    required in order to communicate with containerd. This is a runtime
    dependency.
  - (optional) `grpcio-tools` – only required when re-generating the containerd
    API Python code using `genpb2.sh`.





  In case you need to regenerate or update the Python code for the containerd API,
  in the top-level directory of this repository, run:

  ```bash
  ./genpb2.sh
  ```

  Normally, you should not need to regenerate the grpc/pb2 Python modules unless
  you are a project contributor or maintainer.



  The overall directory structure of the Python containerd API package is as
  follows (inside the `api_1.x/` directories):

  - `containerd/` contains the Python modules generated by protoc as well as a
    very few hand-made modules. In order to avoid polluting the top-level package
    namespace with proto dependencies, `genpb2.sh` "vendorizes" dependencies only
    for such `.proto` files for which no PyPI packages are available, moving such
    dependencies inside the `containerd` top-level Python package namespace.
    - `services/` contains the containerd service API v1.
    - `events/` contains the containerd event definitions.
    - `types/` contains containerd type definitions required by services and
      events.
    - `protobuf/` internal dependency.
    - `vendor/` contains the "vendorized" dependencies.
      - `gogoproto/` modules not available as a PyPI package.
  - `genpb2.sh` is a script to recreate or update the `_pb2.py` and `_pb2_grpc.py`
    Python modules from the containerd API `.proto` file definitions and
    dependencies. See `genpb2.sh` for more information on its workings.



  - [gRPC Basics – Python](https://grpc.io/docs/tutorials/basic/python/).
  - [Protocol Buffers Python Reference: Python Generated
    Code](https://developers.google.com/protocol-buffers/docs/reference/python-generated).
  - [containerd API protocol
    definitions](https://github.com/containerd/containerd/tree/master/api).


pkgId: 495d9b51e6efee883b0afa6bd37a8837293691df3639ae36576f379c67fd91f4
name: python-contaxy
arch: src
version: 0.0.23
epoch: 0
release: 1
summary: Python package template.
url: https://github.com/ml-tooling/contaxy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contaxy-0.0.23-1.src.rpm
checksum_type: sha256
description:
  _WIP: Document python library._



  * Python 3.6+



  Install via pip:

  ```bash
  pip install --upgrade -e path/to/lib
  ```



  After installation, the package can be imported:

  ```python
  import template_package
  ```



  This library uses [black](https://github.com/psf/black) for auto-formatting, [isort](https://github.com/PyCQA/isort) for import sorting, [flake8](https://github.com/PyCQA/flake8) for linting, [mypy](https://github.com/python/mypy) for type checking, and [pydocstyle](https://github.com/PyCQA/pydocstyle) for docstring style checks. All code is written compatible with Python 3.6+, with type hints wherever possible.



  * DeploymentManager:
    * By default, just the DockerDeploymentManager is executed. To execute also the Kubernetes-related tests, a Kubernetes cluster has to be available from where the code is executed. On your local Mac, you can simply start one by executing `kind create cluster`. Then execute the tests by setting the environment variable `KUBE_AVAILABLE=true` (in VS Code, you can for example set the env variable in the `launch.json` or append it in front of the pytest command, e.g. `KUBE_AVAILABLE=true pytest...`)


pkgId: 90a2fe315dde15e44c4f97b547d1ba1fcd9c57c30014e71aa6f5e590f7a2ae63
name: python-contcfg
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A simple tools for container network configuration using tc command.
url: https://pypi.org/project/contcfg/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contcfg-0.0.3-1.src.rpm
checksum_type: sha256
description:
  这是一个简单的用于控制 Docker 容器之间网络的工具。目前只支持设置网络链路的带宽。



  - 设置容器之间的带宽限制
  - 支持动态添加和删除容器
  - 定期调整网络带宽
  - 支持通过 Unix Socket 接收控制消息



  ```bash
  pip install contcfg
  ```



  `contcfg` 通过在 docker 容器内部执行 `tc` 命令来设置网络带宽。[`tc`](https://man7.org/linux/man-pages/man8/tc.8.html)

  在桥接模式下，容器之间的网络通信是通过`veth pair`来实现的。`veth pair`是一对虚拟网络设备，一端连接到容器内部，另一端连接到宿主机的网桥上。`tc`命令可以通过`veth pair`来设置网络带宽。
  ![docker network](https://miro.medium.com/v2/resize:fit:828/format:webp/1*v5c5nl2BoA0BqwqWoj5Y1w.jpeg)

  `contcfg`通过设置容器内部`peer`的`egress`带宽来限制容器的网络带宽。`peer`是`veth pair`的一端，`egress`分别表示出口的方向。



  ```bash
  contcfg --help

  usage: contcfg [-h] [--version] [--socket-path SOCKET_PATH] {start-server,ctrl,stop-server,cli} ...

  Container Network Controller

  positional arguments:
    {start-server,ctrl,stop-server,cli}
                          Sub-command help
      start-server        Start the server
      ctrl                Control the server
      stop-server         Stop the server
      cli                 Run the CLI

  options:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
    --socket-path SOCKET_PATH
                          Path to the Unix socket
  ```



  ```bash
  contcfg cli set c1 c2 100mbit # 设置 c1 和 c2 的带宽为 100mbit
  contcfg cli clear c1 c2 # 清除 c1 和 c2 的带宽限制
  ```


  - docker 容器需要在桥接模式下才能使用 `contcfg`
  - `contcfg` 需要在 root 权限下运行
  - `contcfg` 要求容器内部安装有 `tc` 命令，且启动时需要指定`--cap-add=NET_ADMIN` 权限
  - `contcfg` 会在容器内部执行 `tc` 命令，可能会影响容器内部的网络性能。 仅在测试环境下使用

rpm_license:
  Copyright (c) 2016 The Python Packaging Authority (PyPA)  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.


pkgId: e8cb9928f9ee6bb5168fdb7bc1bcfb779627318b7175bb664cb94ac49061655b
name: python-content-hash
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python implementation of EIP 1577 content hash
url: https://github.com/filips123/ContentHashPy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-content-hash-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![version][icon-version]][link-pypi]
  [![downloads][icon-downloads]][link-pypi]
  [![license][icon-license]][link-license]
  [![python][icon-python]][link-python]
  [![build][icon-build]][link-build]
  [![coverage][icon-coverage]][link-coverage]
  [![quality][icon-quality]][link-quality]
  Python implementation of EIP 1577 content hash.

  This is a simple package made for encoding and decoding content hashes has specified in the [EIP 1577][link-eip-1577].
  This package will be useful for every [Ethereum][link-ethereum] developer wanting to interact with [EIP 1577][link-eip-1577] compliant [ENS resolvers][link-resolvers].
  For JavaScript implementation, see [`pldespaigne/content-hash`][link-javascript-implementation].


  ContentHash requires Python 3.8 or higher.

  The recommended way to install ContentHash is from PyPI with PIP.
  ```bash
  pip install content-hash
  ```

  Alternatively, you can also install it from the source.
  ```bash
  git clone https://github.com/filips123/ContentHashPy.git
  cd ContentHashPy
  pip install .
  ```


  The following codecs are currently supported:
  - `swarm`
  - `ipfs`
  - `ipns`
  Every other codec supported by [`multicodec`][link-multicodec] will be encoded by default in `utf-8`. You can see the full list of the supported codecs [here][link-supported-codecs].

  You can use a `get_codec` function to get codec from the content hash.
  It takes a content hash as a HEX string and returns the codec name. A content hash can be prefixed with a `0x`, but it's not mandatory.
  ```py
  import content_hash
  chash = 'bc037a716b746c776934666563766f367269'
  codec = content_hash.get_codec(chash)
  print(codec) # onion
  ```

  You can use a `decode` function to decode a content hash.
  It takes a content hash as a HEX string and returns the decoded content as a string. A content hash can be prefixed with a `0x`, but it's not mandatory.
  ```py
  import content_hash
  chash = 'e3010170122029f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f'
  value = content_hash.decode(chash)
  print(value) # QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4
  ```

  You can use an `encode` function to encode a content hash.
  It takes a supported codec as a string and a value as a string and returns the corresponding content hash as a HEX string. The output will not be prefixed with a `0x`.
  ```py
  import content_hash
  codec = 'swarm-ns'
  value = 'd1de9994b4d039f6548d191eb26786769f580809256b4685ef316805265ea162'
  chash = content_hash.encode(codec, value)
  print(chash) # e40101701b20d1de9994b4d039f6548d191eb26786769f580809256b4685ef316805265ea162
  ```

  All supported codec profiles are available in [`content_hash/profiles/__init__.py`][link-profiles-file], in `PROFILES` dictionary. You need to add a new profile there. You only need to add a new profile if your codec encoding and decoding are different from `utf-8`.
  Each profile must have the same name as the corresponding codec in the `multicodec` library.
  A profile must also have decode and encode function. They should be passed as a string containing the name of the module for required decode or encode. All such modules are available in [`content_hash/decodes`][link-decodes-directory] and [`content_hash/encodes`][link-encodes-directory].
  Each module name should describe it as much as possible. Its name can only contain valid characters for Python modules.
  Each decode module must have a `decode` function. It must be a function that takes a `bytes` input and returns a `str` result.
  Each encode module must have an `encode` function. It must be a function that takes a `str` input and returns a `bytes` result.
  All inputs and outputs must be the same as in the [JavaScript implementation][link-javascript-implementation]. Multiple profiles can share the same decodes and encodes.

  This library uses [SemVer][link-semver] for versioning. For the versions available, see [the tags][link-tags] on this repository.

  This library is licensed under the MIT license. See the [LICENSE][link-license-file] file for details.
  [icon-version]: https://img.shields.io/pypi/v/content-hash.svg?style=flat-square&label=version
  [icon-downloads]: https://img.shields.io/pypi/dm/content-hash.svg?style=flat-square&label=downloads
  [icon-license]: https://img.shields.io/pypi/l/content-hash.svg?style=flat-square&label=license
  [icon-python]: https://img.shields.io/pypi/pyversions/content-hash?style=flat-square&label=python
  [icon-build]: https://img.shields.io/github/actions/workflow/status/filips123/ContentHashPy/main.yml?style=flat-square&label=build
  [icon-coverage]: https://img.shields.io/scrutinizer/coverage/g/filips123/ContentHashPy.svg?style=flat-square&label=coverage
  [icon-quality]: https://img.shields.io/scrutinizer/g/filips123/ContentHashPy.svg?style=flat-square&label=quality
  [link-pypi]: https://pypi.org/project/content-hash/
  [link-license]: https://choosealicense.com/licenses/mit/
  [link-python]: https://python.org/
  [link-build]: https://github.com/filips123/ContentHashPy/actions
  [link-coverage]: https://scrutinizer-ci.com/g/filips123/ContentHashPy/code-structure/
  [link-quality]: https://scrutinizer-ci.com/g/filips123/ContentHashPy/
  [link-semver]: https://semver.org/
  [link-eip-1577]: https://github.com/ethereum/ercs/blob/master/ERCS/erc-1577.md
  [link-ethereum]: https://www.ethereum.org/
  [link-resolvers]: http://docs.ens.domains/en/latest/introduction.html
  [link-multicodec]: https://github.com/multiformats/multicodec/
  [link-supported-codecs]: https://github.com/multiformats/multicodec/blob/master/table.csv
  [link-tags]: https://github.com/filips123/ContentHashPy/tags/
  [link-license-file]: https://github.com/filips123/ContentHashPy/blob/master/LICENSE
  [link-profiles-file]: https://github.com/filips123/ContentHashPy/blob/master/content_hash/profiles/__init__.py
  [link-decodes-directory]: https://github.com/filips123/ContentHashPy/tree/master/content_hash/decodes/
  [link-encodes-directory]: https://github.com/filips123/ContentHashPy/tree/master/content_hash/encodes/
  [link-javascript-implementation]: https://github.com/pldespaigne/content-hash/

rpm_license:
  MIT License  Copyright (c) 2019 Filip Štamcar <projects@filips.si>  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.


pkgId: 5b69dce5e66e2391b83484116f794bce9480b98a9206a41e91104e58fce5fbea
name: python-content-size-limit-asgi
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: An ASGI3 middleware to implement maximum content size limits (mostly useful for HTTP uploads)
url: https://pypi.org/project/content-size-limit-asgi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-content-size-limit-asgi-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/steinnes/content-size-limit-asgi.svg?style=svg)](https://circleci.com/gh/steinnes/content-size-limit-asgi)

  This is a middleware for ASGI which intercepts the receive() method to raise
  an exception when the read bytes exceed the given limit.



  ```python
  import uvicorn

  from starlette.applications import Starlette
  from starlette.responses import PlainTextResponse

  from content_size_limit_asgi import ContentSizeLimitMiddleware


  app = Starlette()

  @app.route("/", methods=["POST"])
  async def index(request):
      body = await request.body()
      return PlainTextResponse(f"body: {body.decode('utf-8')}")


  app.add_middleware(ContentSizeLimitMiddleware, max_content_size=512)


  if __name__ == "__main__":
      uvicorn.run(app, host="127.0.0.1", port=6001, log_level='debug')
  ```

  To test the app:

  ```
  $ curl --limit-rate 5k -q -v http://localhost:6001/ -d `printf 'A%.0s' {1..99999}`
  *   Trying 127.0.0.1...
  * TCP_NODELAY set
  * Connected to localhost (127.0.0.1) port 6001 (#0)
  > POST / HTTP/1.1
  > Host: localhost:6001
  > User-Agent: curl/7.54.0
  > Accept: */*
  > Content-Length: 99999
  > Content-Type: application/x-www-form-urlencoded
  > Expect: 100-continue
  >
  < HTTP/1.1 100 Continue
  < HTTP/1.1 500 Internal Server Error
  < date: Wed, 12 Jun 2019 14:41:28 GMT
  < server: uvicorn
  < content-length: 21
  < content-type: text/plain; charset=utf-8
  * HTTP error before end of send, stop sending
  <
  * Closing connection 0
  Internal Server Error
  ```

  The app console log should read:
  ```
  $ PYTHONPATH=. python tapp.py
  INFO: Started server process [48160]
  INFO: Waiting for application startup.
  DEBUG: None - ASGI [1] Started
  WARNING 2019-06-12 14:42:18,003 content_size_limit.middleware: ASGI scope of type lifespan is not supported yet
  WARNING: ASGI scope of type lifespan is not supported yet
  DEBUG: None - ASGI [1] Sent {'type': 'lifespan.startup'}
  DEBUG: None - ASGI [1] Received {'type': 'lifespan.startup.complete'}
  INFO: Uvicorn running on http://127.0.0.1:6001 (Press CTRL+C to quit)
  DEBUG: ('127.0.0.1', 52103) - Connected
  DEBUG: ('127.0.0.1', 52103) - ASGI [2] Started
  DEBUG: ('127.0.0.1', 52103) - ASGI [2] Sent {'type': 'http.request', 'body': '<16384 bytes>', 'more_body': True}
  DEBUG: ('127.0.0.1', 52103) - ASGI [2] Received {'type': 'http.response.start', 'status': 500, 'headers': '<...>'}
  INFO: ('127.0.0.1', 52103) - "POST / HTTP/1.1" 500
  DEBUG: ('127.0.0.1', 52103) - ASGI [2] Received {'type': 'http.response.body', 'body': '<21 bytes>'}
  DEBUG: ('127.0.0.1', 52103) - ASGI [2] Raised exception
  ERROR: Exception in ASGI application
  Traceback (most recent call last):
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/uvicorn/protocols/http/httptools_impl.py", line 368, in run_asgi
      result = await app(self.scope, self.receive, self.send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/uvicorn/middleware/message_logger.py", line 58, in __call__
      raise exc from None
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/uvicorn/middleware/message_logger.py", line 54, in __call__
      await self.app(scope, inner_receive, inner_send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/applications.py", line 133, in __call__
      await self.error_middleware(scope, receive, send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/middleware/errors.py", line 122, in __call__
      raise exc from None
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/middleware/errors.py", line 100, in __call__
      await self.app(scope, receive, _send)
    File "/Users/ses/w/content-size-limit-asgi/content_size_limit/middleware.py", line 48, in __call__
      await self.app(scope, wrapper, send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/exceptions.py", line 73, in __call__
      raise exc from None
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/exceptions.py", line 62, in __call__
      await self.app(scope, receive, sender)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/routing.py", line 585, in __call__
      await route(scope, receive, send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/routing.py", line 207, in __call__
      await self.app(scope, receive, send)
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/routing.py", line 40, in app
      response = await func(request)
    File "tapp.py", line 13, in index
      body = await request.body()
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/requests.py", line 167, in body
      async for chunk in self.stream():
    File "/Users/ses/.pyenv/versions/3.7.3/lib/python3.7/site-packages/starlette/requests.py", line 152, in stream
      message = await self._receive()
    File "/Users/ses/w/content-size-limit-asgi/content_size_limit/middleware.py", line 36, in inner
      f"Maximum content size limit ({self.max_content_size}) exceeded ({received} bytes read)"
  content_size_limit.errors.ContentSizeExceeded: Maximum content size limit (512) exceeded (16384 bytes read)
  DEBUG: ('127.0.0.1', 52103) - Disconnected
  ```



  Depending on the ASGI server/framework used, you might not have access to
  the raw stream to stop reading immediately once the maximum content size
  has been exceeded.

  Take this Starlette view for example:


  ```python

  @app.route("/documents/upload", methods=["POST"])
  def upload_document(request):
      data = await request.body()
      if len(data) > Config.MAX_FILE_SIZE:
          return api_400(
              f"This file exceeds the maximum file size we support at this time ({Config.MAX_FILE_SIZE})",
              code=MAX_FILE_SIZE_EXCEEDED,
          )
      ...
  ```

  If the maximum file size is 5MB, and the uploaded file was 50MB, then this
  implementation reads the entire 50MB into memory before rejecting the
  request.


pkgId: 65dd05f0636b5bb6bd75de4b6c6e4d8d67a72a975d183499554116cfb4f04508
name: python-contentconvertor
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Converti des tweets en images pour Instagram
url: https://github.com/leoleducq/Content-Convertor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contentconvertor-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Content-Convertor est un package python permettant de convertir des tweets en fichiers png prêts à être postés sur Instagram.
  ![Exemple](media/banniere.png)

  Pour l'installer, il suffit de lancer la commande : `pip install contentconvertor`.



  Importez le package avec le code suivant :
  ```python
  from contentconvertor import tweet2gram as t2g
  ```
  Ce package comprends différentes fonctions.


  `connexion_to_api` : permet de se connecter à l'API de Twitter. Il faut pour cela rentrer les clés d'API et les tokens d'accès. Pour les obtenir, il faut créer une application sur le site de Twitter.
  **Liste des paramètres dans l'ordre**
  - `bearer_token` : clé d'API (Bearer Token)

  **Retourne la connexion à l'API de Twitter**
  - Code d'exemple :
      ```python
      api = t2g.connexion_to_api(bearer_token="")
      ```

  `get_user_id` : permet de récupérer l'id d'un utilisateur. Il faut pour cela rentrer le nom de l'utilisateur.
  **Liste des paramètres dans l'ordre**
  - `api` : connexion à l'API de Twitter (obtenue avec la fonction `connexion_to_api`)
  - `username` : nom de l'utilisateur (sans le @)

  **Retourne l'id de l'utilisateur**
  - Code d'exemple :
      ```python
      user_id = t2g.get_user_id(api, "iziatask")
      ```

  `get_tweets` : permet de récupérer les tweets d'un utilisateur. Il faut pour cela rentrer le nom de l'utilisateur et le nombre de tweets à récupérer.
  **Liste des paramètres dans l'ordre**
  - Obligatoire :
      - `api` : connexion à l'API de Twitter (obtenue avec la fonction `connexion_to_api`)
      - `user_id` : ID de l'utilisateur (obtenu avec la fonction `get_user_id`)
  - Optionnel :
      - `nb_tweets` : nombre de tweets à récupérer (par défaut : 5)
      - `exclude` : exclure les tweets de type "replies" ou "retweets" (par défaut : None)

  **Retourne une liste de tweets**
  - Code d'exemple :
      - Minimum requis
      ```python
      list_tweets = t2g.get_tweets(api, user_id)
      ```
      - Avec tous les paramètres
      ```python
      list_tweets = t2g.get_tweets(api, user_id, nb_tweets=5, exclude=["replies", "retweets"])
      ```

  `download_tweets` :
  - permet de télécharger au format png les tweets d'un utilisateur.
  - permet de télécharger au format png un tweet en particulier.

  **Liste des paramètres dans l'ordre**
  - Obligatoire :
      - `user` : utilisateur
      - `tweet` : (itérer sur la liste obtenue avec la fonction `get_tweets`)
      ou
      - `link` : lien du tweet
  - Optionnel :
      - `path` : chemin où télécharger les tweets (par défaut : "")
      - `name` : nom du fichier (par défaut : "tweet")
      - `mode` : mode de capture d'écran (par défaut  : 0)
      - `nigh_mode` : mode nuit (par défaut : 2)

  **Retourne rien, vous aurez vos tweets téléchargés au format png, à l'endroit où vous avez lancé votre script.**
  - Code d'exemple :
  - Avec la liste de tweets obtenue avec la fonction `get_tweets`
      - Minimum requis
      ```python
      for tweet in list_tweets.data:
          t2g.download_tweets(user, tweet)
      ```
      - Avec tous les paramètres
      ```python
      for tweet in list_tweets.data:
          t2g.download_tweets(user, tweets, path="images/", name="screenshot", mode=0, nigh_mode=2)
      ```
  - Avec le lien du tweet
      - Minimum requis
      ```python
      t2g.download_tweets(user, link="https://twitter.com/iziatask/status/1606364038195093504")
      ```
      - Avec tous les paramètres
      ```python
      t2g.download_tweets(user, link="https://twitter.com/iziatask/status/1606364038195093504", path="images/", name="screenshot", mode=0, nigh_mode=2)
      ```


  Pour voir un exemple d'utilisation complet, rendez-vous ici : [GitHub](https://github.com/leoleducq/Content-Convertor/blob/master/example/example.py).


pkgId: 1b24cbc37c4f861511901cb4089b40062287b95f7d61ebf58c54f6d7c20accc0
name: python-contentctl
arch: src
version: 4.4.1
epoch: 0
release: 1
summary: Splunk Content Control Tool
url: https://pypi.org/project/contentctl/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contentctl-4.4.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="docs/contentctl_logo_white.png" title="In case you're wondering, it's a capybara" alt="contentctl logo" width="250" height="250"></p>


  If you are already familiar with contentctl, the following common commands may be very useful for basic operations

  | Operation | Command |
  |-----------|---------|
  | Create a repository | `contentctl init` |
  | Validate Your Content | `contentctl validate` |
  | Validate Your Content, performing MITRE Enrichments | `contentctl validate --enrichments`|
  | Build Your App | `contentctl build` |
  | Test All the content in your app, pausing so that you can debug a search if it fails | `contentctl test --post-test-behavior pause_on_failure mode:all` |
  | Test All the content in your app, pausing after every detection to allow debugging | `contentctl test --post-test-behavior always_pause mode:all` |
  | Test 1 or more specified detections. If you are testing more than one detection, the paths are space-separated. You may also use shell-expanded regexes | `contentctl test --post-test-behavior always_pause mode:selected --mode.files detections/endpoint/7zip_commandline_to_smb_share_path.yml detections/cloud/aws_multi_factor_authentication_disabled.yml detections/application/okta*` |
  | Diff your current branch with a target_branch and test detections that have been updated. Your current branch **must be DIFFERENT** than the target_branch | `contentctl test --post-test-behavior always_pause mode:changes --mode.target_branch develop` |
  | Perform Integration Testing of all content. Note that Enterprise Security MUST be listed as an app in your contentctl.yml folder, otherwise all tests will subsequently fail | `contentctl test --enable-integration-testing --post-test-behavior never_pause mode:all` |



  Anyone who has managed a [SOC](#acronyms) will tell you it's hard work.  SOC Managers, Detection Engineers, and Cybersecurity Professionals must understand and manage countless tools and data sources while ensuring the reliability and security of their network and applications.  At the same time, they must be able to detect and react to data breeches, vulnerabilities, and performance degradation in minutes - not seconds or hours.
  These responsibilities leave little time for writing new content - let alone documentation, maintenance, and testing of legacy content.  Existing solutions like Wikis, JIRA tickets, Excel Spreadsheets, and "asking that one team member who knows everything" don't scale and spread information across various systems.

  contentctl is a single application that support the full cycle of security content development (each of the links below will redirect to the appropriate section of the README/Wiki):

  - [Create Content Packs](#contentctl-init) - Version-Controlled collections of searches, documentation, and test data
  - [Add New Content](#contentctl-new---type-type) - searches, macros, lookups, and other content
  - [Statically Validate](#contentctl-validate) Content Against a Well-Defined Baseline
  - [Building](#contentctl-build) a Content Pack for your target - Use a supported output format or design your own
  - [Test](#contentctl-test) your Content Pack on a running Splunk Instance
  - [Deploy](#contentctl-deploy) your Content Pack to Splunk Cloud Instance, via REST API, or create a Splunkbase Application for manual deployment


   
  | Project               | Description                                             |
  | --------------------- | ------------------------------------------------------- |
  | [Splunk Attack Range](https://github.com/splunk/attack_range)          | Easily deploy a preconfigured Splunk Environment locally or on AWS containing a Splunk Instance, Windows and Linux Machines, and Attacker Tools like Kali Linux.  Automatically simulate attacks or run your own|
  | [PurpleSharp Attack Simulation](https://github.com/mvelazc0/PurpleSharp) | Open source adversary simulation tool for Windows Active Directory environments (integrated into Attack Range)|
  | [Red Canary Atomic Red Team](https://github.com/redcanaryco/atomic-red-team)          | Library of attack simulations mapped to the MITRE ATT&CK® framework (integrated into Attack Range)|
  | [Splunk Attack Data](https://github.com/splunk/attack_data)          | Repository of Attack Simulation Data for writing and Testing Detections|                         |
  | [Splunk Security Content](https://github.com/splunk/security_content)          | Splunk Threat Research Team's Content included in the [Enterprise Security Content Update App (ESCU)](https://splunkbase.splunk.com/app/3449)|
  | [Splunk contentctl](https://github.com/splunk/contentctl)          | Generate, validate, build, test, and deploy custom Security Content|
  | [SigmaHQ Sigma Rules](https://github.com/SigmaHQ/sigma) | Official Repository for Sigma Rules. These rules are an excellent starting point for new content. |





  ```mermaid
  graph TD
  starting_state --contentctl init--> contentPack
  newContent{new_content} --contentctl new sigma content--> contentPack
  newContent{new_content} --contentctl new spl content--> contentPack
  contentPack --contentctl validate--> ValidatedContent
  ValidatedContent --contentctl build--> SplunkContent
  ValidatedContent --contentctl docs--> WebsiteDocumentation
  ValidatedContent --contentctl docs--> MITRE_mapDocumentation
  SplunkContent --contentctl test via container-->TestResults
  TestResults --contentctl deploy-->SplunkRESTAPI
  TestResults --contentctl deploy-->SplunkbaseApp
  TestResults --contentctl deploy-->SplunkCloudInstance
  ```



  Testing is run using [GitHub Hosted Runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners).  Ubuntu22.04 is the recommended configuration.
  | Operating System | Supported | Passing Intregration Tests |
  | ---------------- | --------- | ------ |
  | Windows 10       | Yes       | Not tested yet |
  | Windows 11       | Yes       | Not tested yet |
  | Ununtu 20.04 LTS | Yes       | YES (locally + GitHub Actions) |
  | *Ubuntu 22.04 LTS| Yes       | YES (locally + GitHub Actions) |
  | macOS Montery 12       | Yes       | Not tested yet |
  | macOS Ventura 13       | Yes (Intel and Apple Silicon)      | Yes (locally) |

  | Requirement | Supported | Description |  Passing Integration Tests |
  | --------------------- | ----- | ---- | ------ |
  | Python 3.11+ | Yes | contentctl tool is written in Python | Yes (locally + GitHub Actions)  |
  | Docker (local) | Yes | A running Splunk Server is required for Dynamic Testing.  contentctl can automatically create, configure, and destroy this server as a Splunk container during the lifetime of a test. | (locally + GitHub Actions) |
  | Docker (remote) | Planned | A running Splunk Server is required for Dynamic Testing.  contentctl can automatically create, configure, and destroy this server as a Splunk container during the lifetime of a test. | No |



  **Because contentctl uses a large number of dependencies, it's recommended to install contentctl in a virtual environment.
  The instructions below using "poetry" ALSO follow this recommendation.  Poetry will automatically create a new virtual environment for you.
  It is typically recommended to install poetry to the Global Python Environment.**


  ```
  python3.11 -m venv .venv
  source .venv/bin/activate
  pip install contentctl
  ```


  ```
  git clone https://github.com/splunk/contentctl
  cd contentctl
  python3.11 -m pip install poetry
  poetry install
  poetry shell
  contentctl --help
  ```





  Creates a new Content Pack in the current directory as well as a configuration file called [contentctl.yml](/contentctl/templates/contentctl_default.yml) which contains a number of important configuration options.
  The content pack contains a wide variety of content types:
  - [detections](/contentctl/objects/detection.py) - A piece of content that wraps and enriches a Splunk Search.  [Example Detection](/contentctl/templates/detections/anomalous_usage_of_7zip.yml)
  - [baselines](/contentctl/objects/baseline.py) - This content is not currently supported.
  - [lookups](/contentctl//objects/lookup.py) - Static files, such as CSVs, that can be loaded into Splunk for use in lookup commands.  [Example Lookup](https://github.com/splunk/security_content/blob/develop/lookups/attacker_tools.csv)
  - [macros](/contentctl/objects/macro.py) - Common code that is re-used across a wide set of detections.  [Example Macro](/contentctl/templates/macros/security_content_summariesonly.yml)
  - [stories](/contentctl/objects/story.py) - Analytic Stories Allow a developer to tie together a group of detections, for example detections that all relate to Ransomware. [Example Analytic Story](/contentctl/templates/stories/cobalt_strike.yml)


  Performs static validation on all of the content in this Content Pack.  Writing validation is extremely complex.  Each piece of content can one or dozens of fields ranging from free text to numbers to references to other content.  contentctl's build in validation ensures that a number of conditions are met:
  - Required fields in content are defined
  - Values in fields are appropriate.  For example, if content references a Datamodel, then that Datamodel must be valid. Similarly, numeric values that must fall within a certain range must be validated.
  - If a piece of content references other content, then it exists.  For example, if a detection makes use of a macro then the existence and correctness of the macro must be validated.
  - There are no conflicts between content.  For example, two detections cannot have the same name.
  If any of these conditions are not met, then a descriptive error will be printed and contentctl will return a nonzero exit code.  This makes it suitable for running in an automated workflow or other CICD context.  Instead of exiting on the first error, _contentctl validate_ will continue validating all content so that it can present all relevant error before exiting.


  Generates Content Packs in the output format defined in the [contentctl.yml](/contentctl/templates/contentctl_default.yml) configuration file.  These outputs may include {splunk_app, api, ba}.  When _contentctl build_ runs, it first performs a _contentctl validate_ in order to ensure that a valid app is generated.  Note that it is *NOT* required or recommended to run _contentctl validate_ separately if the intention is to build a Content Pack.


  This section is under active development.  It will allow you to a [MITRE Map](https://mitremap.splunkresearch.com/) showing your coverage of MITRE Techniques.  The link here shows the generation of that MITRE Map using the content in Splunk's [security_content repo](https://github.com/splunk/security_content).


  Choose TYPE {detection, story} to create new content for the Content Pack.  The tool will interactively ask a series of questions required for generating a basic piece of content and automatically add it to the Content Pack.


  This section is under development.  The inspect action performs a number of post-build validations. Primarily, it will enable the user to perform an appinspect of the content pack in preparation for deployment onto a Splunk Instance or via Splunk Cloud. It also compares detections in the new build against a prior build, confirming that any changed detections have had their versions incremented (this comparison happens at the savedsearch.conf level, which is why it must happen after the build). Please also note that new versions of contentctl may result in the generation of different savedsearches.conf files without any content changes in YML (new keys at the .conf level which will necessitate bumping of the version in the YML file).


  The reason to build content is so that it can be deployed to your environment.  However, deploying content to multiple servers and different types of infrastructure can be tricky and time-consuming.  contentctl makes this easy by supporting a number of different deployment mechanisms. Deployment targets can be defined in [contentctl.yml](/contentctl/templates/contentctl_default.yml).
  - Deploy via API - Using the REST API, individual pieces of content are deployed to a running server.  This is a great way to deploy all of the content in a content pack, but can also be used to deploy individual peices of content.
  - Deploy to Splunk Cloud via ACS - Using the Automated Private App Vetting (APAV) Feature of the Admin Config Service (ACS), Splunk Cloud customers can easily deploy custom apps to their environments.


  This section is under active development.  It will allow you to easily generate verbose [web-based documentation](https://research.splunk.com) from all of your content.  The link here shows the generation of that documentation using the content in Splunk's [security_content repo](https://github.com/splunk/security_content).


  The static validation performed by *contentctl validate* can only take you so far.  While it's powerful, and fast, it can only tell determine if the content is *syntactically* correct.  *contentctl test* can test your content on real Splunk Infrastructure to ensure there are no errors in your SPL, raw data can be properly ingested/processed/accelerated on your server, your search finds the event(s) you're looking for in raw data, and even provides high-level runtime performance metrics about your searches.    As part of this workflow, a large number of apps will be installed by default.  You can see, and edit, the list of apps in the [app_default.yml](/contentctl/templates/app_default.yml) file.  We plan on making this even easier to update in the future, so stay tuned for updates.
  The following diagram shows this workflow at a high level.

  ```mermaid
  graph TD
  SplunkContainer--start-->SplunkInstance
  SplunkServer-->SplunkInstance
  SplunkInstance--Install Apps-->ConfiguredInstance
  SplunkInstance--Configure Settings-->ConfiguredInstance
  ContentPack--Deploy-->ConfiguredInstance
  ConfiguredInstance--Start Test-->Testing
  Testing--Test Detection-->Detection

  Detection--Replay Raw Data-->Result
  subgraph Test Indidivual Detection
  	Detection--Execute Search-->Result
  end
  Result--Cleanup-->Testing
  Testing--Cleanup-->TestResults
  ```


  There are a number of different testing modes that control which content will be tested.  This can be controlled with the `--mode {}` option at the command line
  - all - This will test all of the content in the content pack. Please note that by default only detections marked production will be tested (detections marked as deprecated or experimental, for example, will be ignored).
  - selected - Detections whose relative paths are provided on the command line will be tested.  This is particularly useful if you would like to troubleshoot or update just a handful of detections and can save a significant amount of time.  For example, to test two detections use the following command `contentctl test --mode selected --detections_list detections/detection_one.yml detections/detection_two.yml`
  - **changes - (not currently supported) If you have a large number of detections and use a branching workflow to create new content or update content, then this is an easy way to automatically find and test only that content automatically.  This prevents you from needing to explicitly list the subset of content to test using "selected"**


  contentctl test's default mode allows it to quickly test all content with requiring user interaction.  This makes it suitable for local tests as well as CI/CD workflows.  However, users often want to troubleshoot a test if it fails.  contentctl allows you to change the tool's behavior if and/or when a test fails:
  - --behavior never_pause - The default behavior.  If a test does not pass, the tool begins the next test immediately
  - --behavior pause_on_failure - If a test fails, then additional information about that test, and the raw SPL of the test, is printed to the terminal.  A user may then click (or CMD+Click) the "LINK" to begin interactively debugging the failed test on the Splunk Server.  Note that the credentials for the server are printed out at the very beginning of the test.  After you have finished debugging the failure, hit "Return" in the terminal to move on to the next test. The attack_data for this test remains loaded on the server for debugging until the user moves on to the next test.
  - --behavior always_pause - Similar to pause_on_failure, but this pauses after every test regardless of whether it passes or fails.


  1. **init** - Initilialize a new repo from scratch so you can easily add your own content to a custom application.
  2. **new** - Creates new content (detection, story)
  3. **validate** - Validates written content
  4. **build** - Builds an application suitable for deployment on a search head using Slim, the Splunk Packaging Toolkit
  5. **deploy** - Deploy the security content pack to a Splunk Server
  6. **docs** - Create documentation as Markdown
  7. **reporting** - Create different reporting files such as a Mitre ATT&CK overlay



  Leveraging the tab completion featureset of the CLI library we're using, you can generate tab completions for `contentctl` automatically, for zsh, bash, and tcsh. For additional details, you can view the docs for the library [here.](https://brentyi.github.io/tyro/tab_completion/)


  If you already have a location for your ZSH tab completions, you only need to run the generation line and can skip the folder creation, configuring the rest to fit with your shell config.

  ```zsh
  mkdir -p ~/.zfunc
  contentctl --tyro-write-completion zsh ~/.zfunc/_contentctl
  echo "fpath+=~/.zfunc" >> ~/.zshrc
  echo "autoload -Uz compinit && compinit" >> ~/.zshrc
  source ~/.zshrc
  ```



  ```bash
  completion_dir=${BASH_COMPLETION_USER_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/bash-completion}/completions/
  mkdir -p $completion_dir
  contentctl --tyro-write-completion bash ${completion_dir}/_contentctl
  ```


  | Acronym | Meaning| Description |
  | --------------------- | ------------------------------------------------------- | ---- |
  | SOC | Security Operation Center | Description of a SoC |
  | DaC | Detection as Code | A systematic approach applying DevOps priciples to Detection Engineering. DaC enables Continuous Integration and Continuous Delivery of Detectionsa via automated validation, testing, and deployment |
  | CICD | Continuous Integration/Continuous Delivery | A modern DevOps practice that encourages users to make small, frequent changes which are automatically tested and deployed. This contrasts with legacy approaches that emphasize large changes which may be manually tested an infrequently deployed. |
  | ACS| Admin Config Service | The [Splunk Admin Config Service](https://docs.splunk.com/Documentation/SplunkCloud/9.0.2209/Config/ACSIntro) is a cloud-native API that provides programmatic self-service administration capabilities for Splunk Cloud Platform. One of its features, Automated Private App Vetting (APAV) enables the installation of custom app on Splunk Cloud instances. |
  | APAV | Automated Private App Vetting | [Automated Private App Vetting](https://docs.splunk.com/Documentation/SplunkCloud/9.0.2209/Config/ManageApps) enables admins to use the ACS API to install, upgrade, and uninstall apps directly on your Splunk Cloud Platform deployment without assistance from Splunk Support. |



  Copyright 2023 Splunk Inc.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 95c55e51b4c104c6d9ff9dc3ab513e88d060e73fb2ff491b506b3d4af35eb4e7
name: python-contentgrid-hal-client
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Python Client for interacting with HAL-forms application
url: https://pypi.org/project/contentgrid-hal-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contentgrid-hal-client-0.0.6-1.src.rpm
checksum_type: sha256
description:
  The `HALFormsClient` library provides a Python client for interacting with RESTful services that use the HAL (Hypertext Application Language) and HAL-Forms standards. This library simplifies the handling of HAL responses and their embedded resources, enabling easy navigation and interaction with APIs that follow the HAL and HAL-Forms specifications.



  - Automatic token management for service accounts.
  - Robust retry mechanisms for HTTP requests.
  - Easy navigation of HAL links and embedded resources.
  - Support for CURIEs (Compact URIs) for compacting and expanding link relations.
  - Handling of common HTTP methods (`GET`, `POST`, `PATCH`, `DELETE`, `PUT`) with ease.
  - Validation and transformation of HAL links and URIs.
  - Customizable client configuration, including endpoint and authentication details.



  To install the library, use pip:

  ```bash
  pip install contentgrid-hal-client
  ```





  To initialize the `HALFormsClient`, you need to provide the endpoint of the HAL service and optionally authentication details:

  ```python
  from halformsclient import HALFormsClient


  client = HALFormsClient(
      client_endpoint="https://api.example.com",
      auth_uri="https://auth.example.com",
      client_id="your_client_id",
      client_secret="your_client_secret",
  )


  client = HALFormsClient(
      client_endpoint="https://api.example.com",
      auth_uri="https://auth.example.com",
      token="your_token"
  )



  client = HALFormsClient(
      client_endpoint="https://api.example.com",
      auth_uri="https://auth.example.com",
      session_cookie="your_session_cookie"
  )

  ```



  You can fetch a HAL resource and interact with it using the provided methods:

  ```python

  resource = client.follow_link(HALLink(uri="/some/resource"))


  print(resource.metadata)


  links = resource.get_links("key")


  embedded_objects = resource.get_embedded_objects_by_key("embedded_key")


  resource.put_data({"key": "value"})
  resource.patch_data({"key": "new_value"})


  resource.delete()
  ```



  CURIEs (Compact URIs) are supported for compacting and expanding link relations:

  ```python
  curie_registry = CurieRegistry(curies=[{"name": "ex", "href": "https://example.com/{rel}"}])
  expanded_uri = curie_registry.expand_curie("ex:some_relation")
  compact_uri = curie_registry.compact_curie("https://example.com/some_relation")
  ```



  The library provides custom exceptions for common HTTP errors:

  ```python
  from halformsclient.exceptions import BadRequest, Unauthorized

  try:
      resource = client.follow_link(HALLink(uri="/some/invalid/resource"))
  except BadRequest as e:
      print(f"Bad request: {str(e)}")
  except Unauthorized as e:
      print(f"Unauthorized: {str(e)}")
  ```

rpm_license:
  Copyright 2024 Xenit Solutions  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 9060000b0ab95a9d1b5e8362eb81f7131e2056d5b3f04eec1a788ba54c2f9a05
name: python-contentstack-utils
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.
url: https://github.com/contentstack/contentstack-utils-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contentstack-utils-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This guide will help you get started with Contentstack Python Utils SDK to build apps powered by Contentstack.



  The latest version of [PyCharm](https://www.jetbrains.com/pycharm/download/) or [Visual Studio Code](https://code.visualstudio.com/download)

  [Python 3](https://docs.python-guide.org/starting/installation/#python-3-installation-guides)

  [Create virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment)

  [Activate virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/#activating-a-virtual-environment)



  To set up Python Utils SDK, Go to terminal and locate the virtual environment path and type below.

  ```python
     pip install contentstack_utils
  ```

  If you are using Contentstack Python SDK in your project by running the following commands,  then “contentstack_utils”  is already imported into your project.



  ```python
     pip install Contentstack
  ```



  ```python
     pip install Contentstack==1.5.1
  ```



  Let’s learn how you can use Utils SDK to render embedded items.



  To render embedded items on the front-end, use the renderContents function, and define the UI elements you want to show in the front-end of your website, as shown in the example code below:

  ```python
      from contentstack_utils.utils import Utils
      from contentstack_utils.render.options import Options

      json_array = {} # should be type of dictionary or list
      option = Options()
      response = Utils.render_content('html_string', json_array, option)
      print(response)

  ```



  Contentstack Utils SDK lets you interact with the Content Delivery APIs and retrieve embedded items from the RTE field of an entry.



  To get an embedded item of a single entry, you need to provide the stack API key, environment name, content type’s UID, and entry’s UID. Then, use the `entry.fetch` function as shown below:

  ```python
  import contentstack

  stack = contentstack.Stack('api_key','delivery_token','environment')
  content_type = stack.content_type("content_type_uid")
  entry = content_type.entry("entry_uid")
  result = entry.fetch()
  if result is not None:
     entry = result['entries']
     Utils.render(entry, ['rich_text_editor', 'some_other_text'], Option())

  ```



  To get embedded items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID.

  ```python
  import contentstack

  stack = contentstack.Stack('api_key','delivery_token','environment')
  query = stack.content_type("content_type_uid").query()
  result = query.find()
  if result is not None and 'entries' in result:
     entry = result['entries']
     for item in range:
         option = Option()
         Utils.render(item, ['rich_text_editor', 'some_other_text'], option)
  ```




  To get supercharged items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID.

  ```python
  import contentstack

  stack = contentstack.Stack('api_key','delivery_token','environment')
  query = stack.content_type("content_type_uid").query()
  result = query.find()
  if result is not None and 'entries' in result:
     entry = result['entries']
     for item in entry:
         option = Option()
         Utils.json_to_html(item, ['paragraph_text'], option)
  ```



  To get supercharged items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID.

  ```python
  import contentstack

  stack = contentstack.Stack('api_key','delivery_token','environment')
  query = stack.content_type("content_type_uid").query()
  result = query.find()
  if result is not None and 'entries' in result:
     entry = result['entries']
     for item in entry:
         option = Option()
         GQL.json_to_html(item, ['paragraph_text'], option)
  ```


pkgId: 80bc638797d3205b2a3467745057112a3bd2c308242667a405540222f7ba76c3
name: python-contest
arch: src
version: 2024.8.0
epoch: 0
release: 1
summary: A console application tester.
url: https://github.com/Lnk2past/contest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contest-2024.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/Lnk2past/contest/workflows/Build/badge.svg)](https://github.com/Lnk2past/contest/actions)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/contest.svg)](https://pypi.python.org/pypi/contest/)
  ![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-red)

  A `CON`sole application `TEST`er. THIS WHOLE REPO NEEDS AN OVERHAUL!



  `contest` is a testing application that exercises a program with configured input and then checks the output with some expected content. Simply: `contest` validates executable output given specific inputs.



  I wrote this for a class that I teach to help with grading. Given the configuration driven nature of it (how else should a testing framework/tool work?) `contest` lets me define multiple test cases for particular programs (assignments) so that not only is grading easier for me, but I can integrate assignments into a grading pipeline so that I can do as little work as possible and my students can get immediate feedback on submissions. Assignments here are usually single-file programs that are not necessarily unit-testable without adding in boilerplate and nonstandard language features. Letting students build normal programs and then verify their behavior is the goal.



  ```shell
  pip install contest
  ```

  You may install from this repo, clone and simply:

  ```shell
  python setup.py install
  ```





  YAML is the preferred choice of input for `contest` for a few reasons, but most notably for its easy to follow syntax and allowance of multiline strings (sorry JSON). `contest` consumes an input file that specifies at least one executable and then whatever additional information is provided. Check out the test skeleton below to see what can be specified; the main ones though are the input and output streams `stdout`, `stderr`, and `stderr` as well and CLI inputs `argv`. You can specify newly generated files that you expect to be created and even go further and specify custom tests (as `Python` files) that cover the things simple I/O comparisons do not. Lastly, you may also specify environment variables to be set during the execution; and you may also scrub the environment before adding custom keys. Note that scrubbing the environment may prevent your executable from running altogether! For now you are better off allowing your current environment to persist and simply overwrite what needs to be set. Environment variables specified within a test-case take precedence over what is in your current environment.



  ```yaml
  executable:                 # !!str, name of the executable to use for all tests
  test-cases:                 # !!seq, list of all test cases
      - name:                 # !!str, name of the test
        scrub-env:            # !!bool, flag to remove the current environment
        env:                  # !!map, environment variables to set
        resources:            # !!seq, list of resources to copy to the test directory, need to provide a src and dst
        executable:           # !!str, name of the executable to use for this test case only
        argv:                 # !!seq, list of arguments to pass to the executable
        stdin:                # !!str || !!seq inputs to standard input stream
          
        returncode:           # !!int, expected return code
        stdout:               # !!str || !!seq || !!map, expected output in standard output stream
          
        stderr:               # !!str || !!seq || !!map, expected output in standard error stream
          
        ofstreams:            # !!seq, list of files to compare
              
        extra-tests:          # !!seq, list of additional modules to load for additional tests
  ```

  \* The stdin field can either be a block of text (one entry to stdin per line) or can be provided as a list.

  \*\* These fields can either be text blocks, lists, or dictionaries. As a text block or list, it should be the expected output as is. As dictionaries the following fields are allowed:

  ```yaml
  text:         # !!str, expected output as a string
  file:         # !!str, file containing the text to compare against. useful for keeping the size of these files small if desired
  empty:        # !!bool, flag to explicitly check if a stream is empty or nonempty. all other checks are ignored
  start:        # !!int, 0-indexed line offset to specify where to start comparisons
  count:        # !!int, number of lines to compare
  ```

  All fields are optional, so long as whatever is (or is not) specified makes sense.

  \*\*\* These fields are dictionaries and in addition to the fields specified above, the following fields are allowed:

  ```yaml
  test-file:    # !!str, path to file generated, absolute or relative to the executable
  exists:       # !!bool, flag to check if the file exists. all other checks are ignored
  binary:       # !!bool, flag to indicate the file is binary
  ```

  Other than `test-file`, each field is optional, so long as whatever is (or is not) specified makes sense.



  Given some configuration you can run `contest` using the following:

  ```shell
  contest <path to configuration file>
  ```

  This will parse the configuration and run the specified test case(s). In the configuration file each test case is defined under the `test-cases` node in the recipe; simply add a new section as desired. You will just need to make sure each test is named uniquely. Here is an example of a test recipe (taken from `examples/native_console_app`):

  ```yaml
  executable: hello_world.exe
  test-cases:
    - name: standard
      stdin: Lnk2past
      stdout: |
        Hello! What is your name?
        Welcome to the world, Lnk2past!
  ```

  Let us break down what this is specifying:

  1. The name of the `executable` to run is

      ```text
      hello_world.exe
      ```

  2. We have a single test-case named

      ```text
      standard
      ```

  3. We define the input to `stdin`, which is a single entry:

      ```text
      Lnk2past
      ```

  4. We define the output to `stdout`, which is:

      ```text
      Hello! What is your name?
      Welcome to the world, Lnk2past!
      ```

  This is really the equivalent of the following in some shell environment:

  ```shell
  ~/project> ./hello_world.exe
  Hello! What is your name?
  Lnk2past
  Welcome to the world, Lnk2past!
  ```

  This means that when running the executable `hello_world.exe` we can expect the input in step 3 to yield the output in step 4. `contest` does this comparison for you! This allows you to write tests that would reflect actual use cases of your executable. Add as many tests as you like to cover various pathways through your program and to cover the various errors your program may encounter.

  Check out the other examples under the `examples` directory.



  `contest` will run each test-case in a separate directory, and will create those directories in the same directory containing the test recipe. This ensures minimal conflict between test cases. For example, if your test recipe contains test cases "foo" and "bar" and is located in "C:\Users\Lnk2past\MyProject", then you can expect the following directory structure:

  ```text
  C:\Users\Lnk2past\MyProject\
  |---src\...
  |---include\...
  |---contest_recipe.yaml
  |---test_output\
      |---foo\...
      |---bar\...
  ```

  Even if your test-case produces no output on disk, the test-output directory will be created.



  You can filter your test-recipes to only run a select few. This may be useful during debugging to only run your new test without needing to run the entire test recipe. You can do this via the `--filter` option. This expects some `regular expression` to filter on. e.g. we can test only those tests that are marked with a specific keyword in their names, say "tracking", by doing the following:

  ```shell
  contest test_recipe.yaml --filter "tracking"
  ```

  Likewise, you can exclude specific tests in order if they are problematic or if you are focusing on other tests. simply use the `--exclude-filters` or `--exclude` for short. So long as you know `regex` you can do whatever you like for filtering your tests!


pkgId: 2c098b1033d319a29a2f9d5601e946a47f576cc3998a3d39f484baada85ab230
name: python-context-python
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Python SDK for the Context API
url: https://pypi.org/project/context-python/
rpm_license: LICENSE.md
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-context-python-0.18.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/context-python.svg)](https://badge.fury.io/py/context-python)

  The Context Python library provides a convenient way to interface with the Context APIs. We include pre-defined classes and operations to interact with API resources.



  ```
  pip install --upgrade context-python
  ```



  The library needs to be configured with your Context API key, which is available in the [Context Settings Dashboard](https://go.getcontext.ai/settings).



  ```python
  import getcontext
  from getcontext.generated.models import Conversation, Message, MessageRole, Rating
  from getcontext.token import Credential
  import os

  token = os.environ.get("GETCONTEXT_TOKEN")

  c = getcontext.ContextAPI(credential=Credential(token))

  c.log.conversation(
      body={
          "conversation": Conversation(
              messages=[
                  Message(
                      message="You are a helpful assistant!",
                      role=MessageRole.SYSTEM,
                  ),
                  Message(
                      message="Hello, world!",
                      role=MessageRole.USER,
                  ),
                  Message(
                      message="Hi, how can I help?",
                      role=MessageRole.ASSISTANT,
                      rating=Rating.POSITIVE,
                  ),
              ],
          )
      }
  )
  ```



  ```python
  import asyncio

  import getcontext.generated.aio as getcontext
  from getcontext.generated.models import Conversation, Message, MessageRole, Rating
  from getcontext.token import AsyncCredential
  import os

  token = os.environ.get("GETCONTEXT_TOKEN")


  async def log():
      async with getcontext.ContextAPI(credential=AsyncCredential(token)) as client:
          await client.log.conversation(
              body={
                  "conversation": Conversation(
                      messages=[
                          Message(
                              message="You are a helpful assistant!",
                              role=MessageRole.SYSTEM,
                          ),
                          Message(
                              message="Hello, world!",
                              role=MessageRole.USER,
                          ),
                          Message(
                              message="Hi, how can I help?",
                              role=MessageRole.ASSISTANT,
                              rating=Rating.POSITIVE,
                          ),
                      ],
                  )
              }
          )


  loop = asyncio.get_event_loop()
  loop.run_until_complete(log())
  loop.close()
  ```



  ```yaml
  python: true
  output-folder: getcontext/generated/
  no-namespace-folders: true
  credential-default-policy-type: BearerTokenCredentialPolicy
  black: true
  python3-only: true
  add-credential: true
  credential-scopes: all
  models-mode: msrest
  ```


pkgId: 9315e077f93f8f167986da2a1dcda1f041a2c13e9efead964cf3091ae6016aed
name: python-context_logging
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Tool for easy logging with current context information
url: https://pypi.org/project/context_logging
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-context_logging-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://badge.fury.io/py/context-logging.svg)](https://pypi.org/project/context_logging)
  [![Python: 3.7+](https://img.shields.io/badge/Python-3.7+-blue.svg)](https://pypi.org/project/context_logging)
  [![Downloads](https://img.shields.io/pypi/dm/context_logging.svg)](https://pypistats.org/packages/context_logging)
  ![CI Status](https://github.com/afonasev/context_logging/workflows/ci/badge.svg?branch=master)
  [![Code coverage](https://codecov.io/gh/Afonasev/context_logging/branch/master/graph/badge.svg)](https://codecov.io/gh/Afonasev/context_logging)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://en.wikipedia.org/wiki/MIT_License)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  Tool for easy logging with current context information.

  ```python
  from context_logging import current_context

  logging.info('before context')


  with Context('my_context'):
      current_context['var'] = 1
      logging.info('in context')
      



  logging.info('after context')

  ```



      pip install context_logging





  ```python
  import logging
  from context_logging import current_context, setup_log_record

  logging.basicConfig(
      format='s s s s s',
      level=logging.INFO,
  )
  setup_log_record()

  current_context['var'] = 1
  logging.info('message')


  ```



  ```python
  from context_logging import Context, current_context

  with Context(var=1):
      assert current_context['var'] == 1

  assert 'var' not in current_context
  ```



  ```python
  with Context(var=1):
      assert current_context == {'var': 1}

      with Context(val=2, var=2):
          assert current_context == {'val': 2, 'var': 2}

      assert current_context == {'var': 1}

  assert 'var' not in current_context
  ```



  ```python
  @Context(var=1)
  def f():
      assert current_context['var'] == 1

  f()
  assert 'var' not in current_context
  ```



  ```python
  ctx = Context(var=1)
  assert 'var' not in current_context

  ctx.start()
  assert current_context['var'] == 1

  ctx.finish()
  assert 'var' not in current_context
  ```


  ```python
  with Context():
      assert 'var' not in current_context
      current_context['var'] = 1
      assert current_context['var'] == 1
  ```



  ```python
  with Context('my_context'):
      pass
  ```



  ```python
  with Context('my_context'):
      time.sleep(1)


  ```

  Default value for log_execution_time param can be changed with env

      export CONTEXT_LOGGING_LOG_EXECUTION_TIME_DEFAULT=0



  ```python
  try:
      with Context(var=1):
          raise Exception(1)
  except Exception as exc:
      assert exc.args = (1, {'var': 1})
  ```

  Default value for fill_exception_context param can be changed with env

      export CONTEXT_LOGGING_FILL_EXEPTIONS_DEFAULT=0



  ```python
  from context_logging import root_context

  root_context['env'] = 'test'
  ```



  ```python
  from context_logging import ContextVarExecutor

  with ContextVarExecutor() as executor:
      executor.submit(...)



  loop.set_default_executor(ContextVarExecutor())  # for asyncio loop
  ```





      make init



      make precommit_hook



      make pretty lint test



      make bump_major
      make bump_minor
      make bump_patch


pkgId: 381ab9f8caf5b0f96f35b39be57527fb99e4dbdcfd8b9bad97f398c864bcfcd2
name: python-contextdecorator
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Create APIs that work as decorators and as context managers.
url: UNKNOWN
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextdecorator-0.10.0-1.src.rpm
checksum_type: sha256
description:
  If you're a library or framework creator then it is nice to be able to create
  APIs that can be used *either* as decorators or context managers.

  The contextdecorator module is a backport of new features added to the
  `contextlib module <http://docs.python.org/library/contextlib.html>`_ in
  Python 3.2. contextdecorator works with Python 2.4+ including Python 3.

  Context managers inheriting from ``ContextDecorator`` have to implement
  ``__enter__`` and ``__exit__`` as normal.
  `__exit__ <http://docs.python.org/reference/datamodel.html#object.__exit__>`_
  retains its optional exception handling even when used as a decorator.

  Example::

     from contextdecorator import ContextDecorator

     class mycontext(ContextDecorator):
        def __enter__(self):
           print 'Starting'
           return self

        def __exit__(self, *exc):
           print 'Finishing'
           return False

     >>> @mycontext()
     ... def function():
     ...    print 'The bit in the middle'
     ...
     >>> function()
     Starting
     The bit in the middle
     Finishing

     >>> with mycontext():
     ...    print 'The bit in the middle'
     ...
     Starting
     The bit in the middle
     Finishing

  Existing context managers that already have a base class can be extended by
  using ``ContextDecorator`` as a mixin class::

     from contextdecorator import ContextDecorator

     class mycontext(ContextBaseClass, ContextDecorator):
        def __enter__(self):
           return self

        def __exit__(self, *exc):
           return False

  contextdecorator also contains an implementation of `contextlib.contextmanager
  <http://docs.python.org/library/contextlib.html#contextlib.contextmanager>`_
  that uses ``ContextDecorator``. The context managers it creates can be used as
  decorators as well as in with statements. ::

     from contextdecorator import contextmanager

     @contextmanager
     def mycontext(*args):
        print 'Started'
        try:
           yield
        finally:
           print 'Finished!'

     >>> @mycontext('some', 'args')
     ... def function():
     ...    print 'In the middle'
     ...
     Started
     In the middle
     Finished!

     >>> with mycontext('some', 'args'):
     ...    print 'In the middle'
     ...
     Started
     In the middle
     Finished!

  Repository and issue tracker:

  * `contextdecorator on google code <http://code.google.com/p/contextdecorator/>`_

  The project is available for download from `PyPI
  <http://pypi.python.org/pypi/contextdecorator>`_
  so it can be easily installed:

      | ``pip install -U contextdecorator``
      | ``easy_install -U contextdecorator``

  The tests require `unittest2 <http://pypi.python.org/pypi/unittest2>`_
  to run.


pkgId: 6dfd9698457a27755f527de63e0cefed171a907dc899e0f473a84fa11bf40c8a
name: python-contextfilter
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: ContextVars Filter for easily enriching log records
url: https://github.com/aviramha/contextfilter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextfilter-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ![Version](https://img.shields.io/pypi/v/contextfilter)
  ![License](https://img.shields.io/pypi/l/contextfilter)
  ![Tests](https://github.com/aviramha/contextfilter/workflows/Test%20Contextfilter/badge.svg?branch=develop)

  Small, helper library for logging contextual information using contextvars in Python 3.7.


  Using pip
  ```
  $ pip install contextfilter
  ```


  ```py
  import logging
  from contextvars import ContextVar
  from contextfilter import ContextVarFilter, ConstContextFilter

  request_id: ContextVar[int] = ContextVar('request_id')
  logger = logging.getLogger("test")
  cf = ContextFilter(request_id=request_id)
  request_id.set(3)
  logger.addFilter(cf)
  logger.info("test")


  cf = ConstContextFilter(some_const=1)
  logger.addFilter(cf)
  logger.info("test")


  ```



  To work on the `contextfilter` codebase, you'll want to fork the project and clone it locally and install the required dependencies via [poetry](https://poetry.eustace.io):

  ```sh
  $ git clone git@github.com:{USER}/contextfilter.git
  $ make install
  ```

  To run tests and linters use command below:

  ```sh
  $ make lint && make test
  ```

  If you want to run only tests or linters you can explicitly specify which test environment you want to run, e.g.:

  ```sh
  $ make lint-black
  ```



  `contextfilter` is licensed under the MIT license. See the license file for details.




  - Renamed `ContextFilter` to `ContextVarFilter` - Revamped the API - It now accepts ContextVars created by caller. Suggestion for design by @bentheiii
  - Added `ConstContextFilter` which adds constant attributes to the log record.
  - Fixed #5


pkgId: ecac39f40a0ff46c1b40c0b38c322c15862cb299a43f7cfc49864268ab02b585
name: python-contextforce-python
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/contextforce-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextforce-python-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This documentation provides detailed information on how to use each function within the `ContextForceClient` SDK and the headers automatically set by the SDK for each one of the functions.


pkgId: d9740960f78cef8576fbf093a4096af4769b152c16540acafae6edd4d69c250d
name: python-contextily
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Context geo-tiles in Python
url: https://pypi.org/project/contextily/
rpm_license: 3-Clause BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextily-1.6.2-1.src.rpm
checksum_type: sha256
description:
  `contextily` is a small Python 3 (3.9 and above) package to retrieve tile maps from the
  internet. It can add those tiles as basemap to matplotlib figures or write tile
  maps to disk into geospatial raster files. Bounding boxes can be passed in both
  WGS84 (`EPSG:4326`) and Spheric Mercator (`EPSG:3857`). See the notebook
  `contextily_guide.ipynb` for usage.

  [![Tests](https://github.com/geopandas/contextily/actions/workflows/tests.yaml/badge.svg)](https://github.com/geopandas/contextily/actions/workflows/tests.yaml)
  [![codecov](https://codecov.io/gh/geopandas/contextily/branch/main/graph/badge.svg?token=5Eu3L1peBb)](https://codecov.io/gh/geopandas/contextily)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/geopandas/contextily/main?urlpath=lab/tree/notebooks/intro_guide.ipynb)

  ![Tiles](tiles.png)

  The current tile providers that are available in contextily are the providers
  defined in the [`xyzservices`](https://xyzservices.readthedocs.io)
  package. This includes some popular tile maps, such as:

  * The standard [OpenStreetMap](http://openstreetmap.org) map tiles
  * Toner, Terrain and Watercolor map tiles by [Stamen Design](http://stamen.com)



  * `mercantile`
  * `numpy`
  * `matplotlib`
  * `pillow`
  * `rasterio`
  * `requests`
  * `geopy`
  * `joblib`
  * `xyzservices`



  **Python 3 only** (3.9 and above)

  [Latest released version](https://github.com/geopandas/contextily/releases/), using pip:

  ```sh
  pip3 install contextily
  ```

  or conda:

  ```sh
  conda install contextily
  ```



  `contextily` is developed by a community of enthusiastic volunteers. You can see a full list [here](https://github.com/geopandas/contextily/graphs/contributors).

  If you would like to contribute to the project, have a look at the list of [open issues](https://github.com/geopandas/contextily/issues), particularly those labeled as [good first contributions](https://github.com/geopandas/contextily/issues?q=is%3Aissue+is%3Aopen+label%3Agood-first-contribution).



  BSD compatible. See `LICENSE.txt`


pkgId: 0ed271a69f0e62a6f8f6ee07dfe32d98ac7dd5c89f3a6e1605247966d7cc2711
name: python-contextlib2
arch: src
version: 21.6.0
epoch: 0
release: 1
summary: Backports and enhancements for the contextlib module
url: http://contextlib2.readthedocs.org
rpm_license: PSF License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextlib2-21.6.0-1.src.rpm
checksum_type: sha256
description:
  As a backport of Python standard library software, the implementation, test
  suite and other supporting files for this project are distributed under the
  Python Software License used for the CPython reference implementation.
  The one exception is the included type hints file, which comes from the
  ``typeshed`` project, and is hence distributed under the Apache License 2.0.


pkgId: 186bb36b8b0e0d68370be231530b4c1714fe75920026a1377e509cae7be95ed1
name: python-contextlib3
arch: src
version: 3.10.0
epoch: 0
release: 1
summary: Backport of Python 3.10 standard library’s contextlib module to other python 3 versions
url: https://github.com/tomgrin10/contextlib3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextlib3-3.10.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/contextlib3)](https://pypi.org/project/contextlib3/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/contextlib3)](https://pypi.org/project/contextlib3/)
  [![PyPI License](https://img.shields.io/pypi/l/contextlib3)](https://pypi.org/project/contextlib3/)
  [![Code Style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black/)

  Backport of Python 3.10 standard library’s contextlib module to other python 3 versions.


pkgId: 5c90616c49352e68d849aa6f7f085bebed95a741668b4256958c2985300ee59f
name: python-contextlogger
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A logging boilerplate enhanced by the use of contextvars
url: https://github.com/kolitiri/contextlogger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextlogger-1.0.1-1.src.rpm
checksum_type: sha256
description:
  1. [Description](#description)
  2. [Requirements](#requirements)
  3. [Installation](#installation)
  4. [Usage](#usage)
  5. [Tutorial](#tutorial)
      * [Logging configuration](#logging-configuration)
      * [Logging without context](#logging-without-context)
      * [Logging with static context](#logging-with-static-context)
      * [Logging with dynamic context](#logging-with-dymanic-context)
      * [Logging with context in multiple modules](#logging-multiple)
      * [Structured logging](#structured-logging)
  6. [Version Updates](#versionupdates)
  7. [Contributions](#contributions)




  A simple logger that uses the [contextvars](https://docs.python.org/3/library/contextvars.html) library to inject contextual details in your logs.

  **Source Code**: https://github.com/kolitiri/contextlogger


  Python 3.7+


  ```python
  pip install contextlogger
  ```


  This is a bare minimum example to get you started. (Check the tutorial below for some more realistic scenarios)

  ```python
  """ my_app.py """
  import asyncio
  import logging
  from uuid import uuid4

  from contextlogger import CLogVars, CLogVar, getCLogger



  clogger = getCLogger(__name__)
  console_handler = logging.StreamHandler()
  clogger.addHandler(console_handler)
  clogger.setLevel('DEBUG')


  clogger.clogvars = CLogVars(
      static=CLogVar(name='static'),
      request_id=CLogVar(name='request_id', setter=lambda: str(uuid4())),
  )

  async def my_func():
      
      clogger.setvar('static', value=1)

      
      clogger.setvar('request_id')

      clogger.info(f"Hello World!")


  async def main():
      await asyncio.gather(my_func())

  if __name__ == '__main__':
      asyncio.run(main())
  ```


  ```
  {'static': 1, 'request_id': '7e643fe2-bc7a-498c-a0fe-66ae58c671da'} Hello World!
  ```


  This should be as simple as it gets!

  Let's assume that we have a package with the following structure:
  ```
  my_app/
  │
  ├── my_app/
  │   ├── __init__.py
  │   ├── runner.py
  ├── main.py
  ```

  where your **main.py** is simply running the two tasks defined in your runner.py module.

  ```python
  """ main.py """
  import asyncio

  from my_app.runner import task1, task2


  async def main():
  	await asyncio.gather(
  		task1(),
  		task2(),
  	)
  asyncio.run(main())
  ```

  ```python
  """ runner.py """
  async def task1():
  	pass

  async def task2():
  	pass
  ```



  In the **\_\_init\_\_.py** module of your project setup your logger.
  This will be very similar to the way you would normally configure a regular logger from the standard library.
  ```python
  """ __init__.py """
  import logging
  from logging.handlers import TimedRotatingFileHandler
  import os

  import contextlogger


  clogger = contextlogger.getCLogger(__name__)


  clogger.setLevel('DEBUG')


  logging_format = "s s s s"
  formatter = logging.Formatter(logging_format)


  console_handler = logging.StreamHandler()
  console_handler.setFormatter(formatter)
  clogger.addHandler(console_handler)


  LOG_DIR = 'logs'
  APP = 'MY-APP'
  if not os.path.exists(LOG_DIR):
  	os.makedirs(LOG_DIR)

  file_handler = TimedRotatingFileHandler(f"{LOG_DIR}/{APP}.log", when="midnight", interval=1)
  file_handler.setFormatter(formatter)
  file_handler.suffix = "%Y%m%d"
  clogger.addHandler(file_handler)
  ```
  So far, the only thing that we have done differently is that instead of using the **getLogger** function of the standard logging library, we used the **getCLogger** function from the contextlogger library.



  Once your logger configuration is set, you can use your logger in your **runner.py** file (or whatever file you choose as your entry point)
  ```python
  """ runner.py """
  from my_app import clogger

  async def task1():
  	clogger.info(f"Hello from {task1.__name__}")

  async def task2():
  	clogger.info(f"Hello from {task2.__name__}")
  ```

  As expected, if you run your **main.py** the output of the clogger will be:
  ```
  2020-12-06 18:07:27,008 INFO my_app Hello from task1
  2020-12-06 18:07:27,009 INFO my_app Hello from task2
  ```



  Now lets add some context to our logging.

  We can do that by adding a custom UserDict (CLogVars) of **CLogVar** (context log variables) to our logger.

  Let's add a 'static' attribute... Not very useful but why not!

  ```python
  """ runner.py """
  from contextlogger import CLogVars, CLogVar
  from my_app import clogger

  clogger.clogvars = CLogVars(
  	static=CLogVar(name='static'),
  )

  async def task1():
      
  	clogger.setvar('static', value=1)

  	clogger.info(f"Hello from {task1.__name__}")

  async def task2():
      
  	clogger.setvar('static', value=2)

  	clogger.info(f"Hello from {task2.__name__}")
  ```
  And voila! Now the output of the clogger includes our static values:

  ```
  2020-12-06 18:12:07,505 INFO my_app {'static': 1} Hello from task1
  2020-12-06 18:12:07,505 INFO my_app {'static': 2} Hello from task2
  ```



  Ok but that was not very handy, right? Let's do something more realistic. Let's pretend that this is our FastApi application and we want to add a 'request_id' to every request we receive.

  Now, things get interesting! Our CLogVar can also accept a 'setter' argument which is a function that generates a new uuid every time we enter a new context. Every time we call the **setvar** without a value, it will try to find a **setter** to do the job!

  ```python
  from uuid import uuid4

  from contextlogger import CLogVars, CLogVar
  from my_app import clogger

  clogger.clogvars = CLogVars(
  	static=CLogVar(name='static'),
  	request_id=CLogVar(name='request_id', setter=lambda: str(uuid4())),
  )

  async def task1():
  	
  	clogger.setvar('static', value=1)

  	
  	clogger.setvar('request_id')

  	clogger.info(f"Hello from {task1.__name__}")

  async def task2():
      
  	clogger.setvar('static', value=2)

  	
  	clogger.setvar('request_id')

  	clogger.info(f"Hello from {task2.__name__}")
  ```

  And here we are, with something a lot more useful than just a static value:
  ```
  2020-12-06 18:21:17,626 INFO my_app {'request_id': 'd3961bd9-f701-4222-ad32-f204e9eb968a', 'static': 1} Hello from task1
  2020-12-06 18:21:17,626 INFO my_app {'request_id': '6d4cdab2-e24b-481b-b54b-12c6ee9bcc1b', 'static': 2} Hello from task2
  ```



  Finally, let's add an extra module just for the sake of it.

  Now our directory will look like:
  ```
  my_app/
  │
  ├── my_app/
  │   ├── __init__.py
  │   ├── runner.py
  │   ├── another_module.py
  ├── main.py
  ```

  where our **another_module.py** simply imports the logger and uses it in a function:
  ```python
  from my_app import clogger


  def test():
  	clogger.info(f"Hello from another_module")
  ```

  Now, if we call our test function inside the task1 of our **runner.py**:

  ```python
  from uuid import uuid4

  from contextlogger import CLogVars, CLogVar
  from my_app import clogger
  from my_app.another_module import test

  clogger.clogvars = CLogVars(
  	static=CLogVar(name='static'),
  	request_id=CLogVar(name='request_id', setter=lambda: str(uuid4())),
  )

  async def task1():
  	
  	clogger.setvar('static', value=1)

  	
  	clogger.setvar('request_id')

  	clogger.info(f"Hello from {task1.__name__}")

  	test()

  async def task2():
      
  	clogger.setvar('static', value=2)

  	
  	clogger.setvar('request_id')

  	clogger.info(f"Hello from {task2.__name__}")
  ```

  we should see that the log line that is printed inside our **another_module.py** has the same request_id and static values with the log line that is printed in task1. And this is expected since they belong to the same context.

  ```
  2020-12-06 18:33:36,634 INFO my_app {'request_id': '1eff5e40-4b05-4cd1-bd9c-edbee85d2995', 'static': 1} Hello from task1
  2020-12-06 18:33:36,635 INFO my_app {'request_id': '1eff5e40-4b05-4cd1-bd9c-edbee85d2995', 'static': 1} Hello from another_module
  2020-12-06 18:33:36,635 INFO my_app {'request_id': 'ec68779f-46f6-4ea0-a003-9ddb053887e1', 'static': 2} Hello from task2
  ```



  If you prefer structured logging, you can create the **clogger** instance using the 'structured' argument, which will cause the message to be printed in a structured format.

  Then, just change your formatter accordingly.

  ```python

  """ __init__.py """
  import logging
  from logging.handlers import TimedRotatingFileHandler
  import os


  import contextlogger


  clogger = contextlogger.getCLogger(__name__, structured=True)


  logging_format = "{'time': 's', 'level': 's', 'name': 's', s}"
  formatter = logging.Formatter(logging_format)


  console_handler = logging.StreamHandler()
  console_handler.setFormatter(formatter)
  clogger.addHandler(console_handler)


  LOG_DIR = 'logs'
  APP = 'MY-APP'
  if not os.path.exists(LOG_DIR):
  	os.makedirs(LOG_DIR)

  file_handler = TimedRotatingFileHandler(f"{LOG_DIR}/{APP}.log", when="midnight", interval=1)
  file_handler.setFormatter(formatter)
  file_handler.suffix = "%Y%m%d"
  clogger.addHandler(file_handler)
  ```
  The output result will become:

  ```
  {'time': '2020-12-11 15:52:11,487', 'level': 'INFO', 'name': 'my_app', 'msg': 'Hello from task1', 'static': '1', 'request_id': 'cc75cb8f-f267-4406-b49c-fc2196a686c6'}
  {'time': '2020-12-11 15:52:11,487', 'level': 'INFO', 'name': 'my_app', 'msg': 'Hello from another_module', 'static': '1', 'request_id': 'cc75cb8f-f267-4406-b49c-fc2196a686c6'}
  {'time': '2020-12-11 15:52:11,487', 'level': 'INFO', 'name': 'my_app', 'msg': 'Hello from task2', 'static': '2', 'request_id': '7117cdb4-a0dd-4e12-89a5-756a03d7f8b1'}
  ```


  **1.0.0**: Introduces breaking changes. CLogger.clogvars has been converted from a List to a custom UserDict to maintain consistency between get/set functionality.


  If you want to contribute to the package, please have a look at the CONTRIBUTING.md file for some basic instructions.
  Feel free to reach me in my email or my twitter account, which you can find in my github profile!


  This project is licensed under the terms of the MIT license.


  Christos Liontos


pkgId: 6d17590d486cfb58783c8772d174b0c1961f1dfb4cf61a41fa1ef68bdd743f97
name: python-contextual-anomaly-detector
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Contextual matrix profile for anomaly detection in building electrical loads
url: https://pypi.org/project/contextual-anomaly-detector/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextual-anomaly-detector-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Matrix Profile is an algorithm capable to discover motifs and discords in time series data. It is a powerful tool that
  by calculating the (z-normalized) Euclidean distance between any subsequence within a time series and its nearest
  neighbor it is able to provide insights on potential anomalies and/or repetitive patterns. In the field of building
  energy management it can be employed to detect anomalies in electrical load timeseries.

  This tool is a Python implementation of the Matrix Profile algorithm that employs contextual information (such as
  external air temperature) to identify abnormal pattens in electrical load subsequences that start in predefined sub
  daily time windows, as shown in the following figure.

  ![](./docs/example.png)

  **Table of Contents**

  * [Usage](#usage)
      * [Data format](#data-format)
      * [Run locally](#run-locally)
      * [Run with Docker](#run-with-docker)
  * [Additional Information](#additional-information)
  * [Cite](#cite)
  * [Contributors](#contributors)
  * [License](#license)



  The tool comes with a CLI that helps you to execute the script with the desired commands

  ```console
  $ python -m src.cmp.main -h

  Matrix profile

  positional arguments:
    input_file     Path to file
    variable_name  Variable name
    output_file    Path to the output file

  options:
    -h, --help     show this help message and exit
  ```

  The arguments to pass to the script are the following:

  * `input_file`: The input dataset via an HTTP URL. The tool should then download the dataset from that URL; since it's a
    pre-signed URL, the tool would not need to deal with authentication—it can just download the dataset directly.
  * `variable_name`: The variable name to be used for the analysis (i.e., the column of the csv that contains the
    electrical load under analysis).
  * `output_file`: The local path to the output HTML report. The platform would then get that HTML report and upload it to
    the object
    storage service for the user to review later.

  You can run the main script through the console using either local files or download data from an external url. This
  repository comes with a sample dataset ([data.csv](.src/cmp/data/data.csv)) that you can use to generate a report and
  you can pass the local path
  as `input_file` argument as follows:



  The tool requires the user to provide a csv file as input that contains electrical power timeseries for a specific
  building, meter or energy system (e.g., whole building electrical power timeseries). The `csv` is a wide table format as
  follows:

  ```csv
  timestamp,column_1,temp
  2019-01-01 00:00:00,116.4,-0.6
  2019-01-01 00:15:00,125.6,-0.9
  2019-01-01 00:30:00,119.2,-1.2
  ```

  The csv must have the following columns:

  - `timestamp` [case sensitive]: The timestamp of the observation in the format `YYYY-MM-DD HH:MM:SS`. This column is
    supposed to be in
    UTC timezone string format. It will be internally transformed by the tool into the index of the dataframe.
  - `temp` [case sensitive]: Contains the external air temperature in Celsius degrees. This column is required to perform
    thermal sensitive
    analysis on the electrical load.
  - `column_1`: Then the dataframe may have `N` arbitrary columns that refers to electrical load time series. The user has
    to specify the column name that refers to the electrical load time series in the `variable_name` argument.



  Create virtual environment and activate it and install dependencies:

  - Makefile
    ```bash
    make setup
    ```

  - Linux:
    ```bash
    python3 -m venv .venv
    source .venv/bin/activate
    pip install poetry
    poetry install
    ```
  - Windows:
    ```bash
    python -m venv venv
    venv\Scripts\activate
    pip install poetry
    poetry install
    ```

  Now you can run the script from the console by passing the desired arguments. In the following we pass the sample
  dataset [`data.csv`](src/cmp/data/data.csv) as input file and the variable `Total_Power` as the variable name to be used
  for the analysis. The output file will be saved in the [`results`](src/cmp/results) folder.

  ```console
  $ python -m src.cmp.main src/cmp/data/data.csv Total_Power src/cmp/results/reports/report.html

  2024-08-13 12:45:42,821 [INFO](src.cmp.utils) ⬇️ Downloading file from <src/cmp/data/data.csv>
  2024-08-13 12:45:43,070 [INFO](src.cmp.utils) 📊 Data processed successfully

  *********************
  CONTEXT 1 : Subsequences of 05:45 h (m = 23) that start in [00:00,01:00) (ctx_from00_00_to01_00_m05_45)
  99.997%        0.0 sec

  - Cluster 1 (1.660 s)   -> 1 anomalies
  - Cluster 2 (0.372 s)   -> 3 anomalies
  - Cluster 3 (0.389 s)   -> 4 anomalies
  - Cluster 4 (0.593 s)   -> 5 anomalies
  - Cluster 5 (-)         -> no anomalies green

  [...]

  2024-08-13 12:46:27,187 [INFO](__main__) TOTAL 0 min 44 s
  2024-08-13 12:46:32,349 [INFO](src.cmp.utils) 🎉 Report generated successfully on src/cmp/results/reports/report.html

  ```

  At the end of the execution you can find the report in the path specified by the `output_file` argument, in this case
  you will find it in the [`results`](src/cmp/results) folder.



  Build the docker image.

  - Makefile
    ```bash
    make docker-build
    ```
  - Linux:
    ```bash
    docker build -t cmp .
    ```

  Run the docker image with the same arguments as before

  - Makefile
    ```bash
    make docker-run
    ```
  - Linux:
    ```bash
    docker run cmp data/data.csv Total_Power results/reports/report.html
    ```

  At the end of the execution you can find the results in the [`results`](src/cmp/results) folder inside the docker
  container.



  You can cite this work by using the following reference or either though [this Bibtex file](./docs/ref.bib) or the
  following plain text citation

  > Chiosa, Roberto, et al. "Towards a self-tuned data analytics-based process for an automatic context-aware detection
  > and
  > diagnosis of anomalies in building energy consumption timeseries." Energy and Buildings 270 (2022): 112302.



  - Author [Roberto Chiosa](https://github.com/RobertoChiosa)



  - Series Distance Matrix repository (https://github.com/predict-idlab/seriesdistancematrix)
  - Stumpy Package (https://stumpy.readthedocs.io/en/latest/)



  This code is licensed under the MIT License - see the [LICENSE](LICENSE.md) file for details.


pkgId: 38d56ed4464cf95236d5ded7077cb4c08c0849f4806eaeebfd80f9e12d492814
name: python-contextualSpellCheck
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Contextual spell correction using BERT (bidirectional representations)
url: https://github.com/R1j1t/contextualSpellCheck
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextualSpellCheck-0.4.4-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/R1j1t/contextualSpellCheck"><img src="https://user-images.githubusercontent.com/22280243/82138959-2852cd00-9842-11ea-918a-49b2a7873ef6.png" width="276" height="120" align="right" /></a>

  Contextual word checker for better suggestions

  [![license](https://img.shields.io/github/license/r1j1t/contextualSpellCheck)](https://github.com/R1j1t/contextualSpellCheck/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/contextualSpellCheck?color=green)](https://pypi.org/project/contextualSpellCheck/)
  [![Python-Version](https://img.shields.io/badge/Python-3.6+-green)](https://github.com/R1j1t/contextualSpellCheck#install)
  [![Downloads](https://pepy.tech/badge/contextualspellcheck/week)](https://pepy.tech/project/contextualspellcheck)
  [![GitHub contributors](https://img.shields.io/github/contributors/r1j1t/contextualSpellCheck)](https://github.com/R1j1t/contextualSpellCheck/graphs/contributors)
  [![Help Wanted](https://img.shields.io/badge/Help%20Wanted-Task%20List-violet)](https://github.com/R1j1t/contextualSpellCheck#task-list)
  [![DOI](https://zenodo.org/badge/254703118.svg)](https://zenodo.org/badge/latestdoi/254703118)



  It is essential to understand that identifying whether a candidate is a spelling error is a big task.

  > Spelling errors are broadly classified as non- word errors (NWE) and real word errors (RWE). If the misspelt string is a valid word in the language, then it is called an RWE, else it is an NWE.
  >
  > -- [Monojit Choudhury et. al. (2007)][1]

  This package currently focuses on Out of Vocabulary (OOV) word or non-word error (NWE) correction using BERT model. The idea of using BERT was to use the context when correcting OOV. To improve this package, I would like to extend the functionality to identify RWE, optimising the package, and improving the documentation.



  The package can be installed using [pip](https://pypi.org/project/contextualSpellCheck/). You would require python 3.6+

  ```bash
  pip install contextualSpellCheck
  ```



  **Note:** For use in other languages check [`examples`](https://github.com/R1j1t/contextualSpellCheck/tree/master/examples) folder.



  ```python
  >>> import contextualSpellCheck
  >>> import spacy
  >>> nlp = spacy.load("en_core_web_sm")
  >>>
  >>> ## We require NER to identify if a token is a PERSON
  >>> ## also require parser because we use `Token.sent` for context
  >>> nlp.pipe_names
  ['tok2vec', 'tagger', 'parser', 'ner', 'attribute_ruler', 'lemmatizer']
  >>> contextualSpellCheck.add_to_pipe(nlp)
  >>> nlp.pipe_names
  ['tok2vec', 'tagger', 'parser', 'ner', 'attribute_ruler', 'lemmatizer', 'contextual spellchecker']
  >>>
  >>> doc = nlp('Income was $9.4 milion compared to the prior year of $2.7 milion.')
  >>> doc._.outcome_spellCheck
  'Income was $9.4 million compared to the prior year of $2.7 million.'
  ```

  Or you can add to spaCy pipeline manually!

  ```python
  >>> import spacy
  >>> import contextualSpellCheck
  >>>
  >>> nlp = spacy.load("en_core_web_sm")
  >>> nlp.pipe_names
  ['tok2vec', 'tagger', 'parser', 'ner', 'attribute_ruler', 'lemmatizer']
  >>> # You can pass the optional parameters to the contextualSpellCheck
  >>> # eg. pass max edit distance use config={"max_edit_dist": 3}
  >>> nlp.add_pipe("contextual spellchecker")
  <contextualSpellCheck.contextualSpellCheck.ContextualSpellCheck object at 0x1049f82b0>
  >>> nlp.pipe_names
  ['tok2vec', 'tagger', 'parser', 'ner', 'attribute_ruler', 'lemmatizer', 'contextual spellchecker']
  >>>
  >>> doc = nlp("Income was $9.4 milion compared to the prior year of $2.7 milion.")
  >>> print(doc._.performed_spellCheck)
  True
  >>> print(doc._.outcome_spellCheck)
  Income was $9.4 million compared to the prior year of $2.7 million.
  ```

  After adding `contextual spellchecker` in the pipeline, you use the pipeline normally. The spell check suggestions and other data can be accessed using [extensions](#Extensions).



  ```python
  >>> doc = nlp(u'Income was $9.4 milion compared to the prior year of $2.7 milion.')
  >>>
  >>> # Doc Extention
  >>> print(doc._.contextual_spellCheck)
  True
  >>> print(doc._.performed_spellCheck)
  True
  >>> print(doc._.suggestions_spellCheck)
  {milion: 'million', milion: 'million'}
  >>> print(doc._.outcome_spellCheck)
  Income was $9.4 million compared to the prior year of $2.7 million.
  >>> print(doc._.score_spellCheck)
  {milion: [('million', 0.59422), ('billion', 0.24349), (',', 0.08809), ('trillion', 0.01835), ('Million', 0.00826), ('%', 0.00672), ('##M', 0.00591), ('annually', 0.0038), ('##B', 0.00205), ('USD', 0.00113)], milion: [('billion', 0.65934), ('million', 0.26185), ('trillion', 0.05391), ('##M', 0.0051), ('Million', 0.00425), ('##B', 0.00268), ('USD', 0.00153), ('##b', 0.00077), ('millions', 0.00059), ('%', 0.00041)]}
  >>>
  >>> # Token Extention
  >>> print(doc[4]._.get_require_spellCheck)
  True
  >>> print(doc[4]._.get_suggestion_spellCheck)
  'million'
  >>> print(doc[4]._.score_spellCheck)
  [('million', 0.59422), ('billion', 0.24349), (',', 0.08809), ('trillion', 0.01835), ('Million', 0.00826), ('%', 0.00672), ('##M', 0.00591), ('annually', 0.0038), ('##B', 0.00205), ('USD', 0.00113)]
  >>>
  >>> # Span Extention
  >>> print(doc[2:6]._.get_has_spellCheck)
  True
  >>> print(doc[2:6]._.score_spellCheck)
  {$: [], 9.4: [], milion: [('million', 0.59422), ('billion', 0.24349), (',', 0.08809), ('trillion', 0.01835), ('Million', 0.00826), ('%', 0.00672), ('##M', 0.00591), ('annually', 0.0038), ('##B', 0.00205), ('USD', 0.00113)], compared: []}
  ```



  To make the usage easy, `contextual spellchecker` provides custom spacy extensions which your code can consume. This makes it easier for the user to get the desired data. contextualSpellCheck provides extensions on the `doc`, `span` and `token` level. The below tables summarise the extensions.



  | Extension | Type | Description | Default |
  |------------------------------|---------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
  | doc._.contextual_spellCheck | `Boolean` | To check whether contextualSpellCheck is added as extension | `True` |
  | doc._.performed_spellCheck | `Boolean` | To check whether contextualSpellCheck identified any misspells and performed correction | `False` |
  | doc._.suggestions_spellCheck | `{Spacy.Token:str}` | if corrections are performed, it returns the mapping of misspell token (`spaCy.Token`) with suggested word(`str`) | `{}` |
  | doc._.outcome_spellCheck | `str` | corrected sentence(`str`) as output | `""` |
  | doc._.score_spellCheck | `{Spacy.Token:List(str,float)}` | if corrections are identified, it returns the mapping of misspell token (`spaCy.Token`) with suggested words(`str`) and probability of that correction | `None` |


  | Extension | Type | Description | Default |
  |-------------------------------|---------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------|
  | span._.get_has_spellCheck | `Boolean` | To check whether contextualSpellCheck identified any misspells and performed correction in this span | `False` |
  | span._.score_spellCheck | `{Spacy.Token:List(str,float)}` | if corrections are identified, it returns the mapping of misspell token (`spaCy.Token`) with suggested words(`str`) and probability of that correction for tokens in this `span` | `{spaCy.Token: []}` |



  | Extension | Type | Description | Default |
  |-----------------------------------|-----------------|-------------------------------------------------------------------------------------------------------------|---------|
  | token._.get_require_spellCheck | `Boolean` | To check whether contextualSpellCheck identified any misspells and performed correction on this `token` | `False` |
  | token._.get_suggestion_spellCheck | `str` | if corrections are performed, it returns the suggested word(`str`) | `""` |
  | token._.score_spellCheck | `[(str,float)]` | if corrections are identified, it returns suggested words(`str`) and probability(`float`) of that correction | `[]` |



  At present, there is a simple GET API to get you started. You can run the app in your local and play with it.

  Query: You can use the endpoint http://127.0.0.1:5000/?query=YOUR-QUERY
  Note: Your browser can handle the text encoding

  ```
  GET Request: http://localhost:5000/?query=Income%20was%20$9.4%20milion%20compared%20to%20the%20prior%20year%20of%20$2.7%20milion.
  ```

  Response:

  ```json
  {
      "success": true,
      "input": "Income was $9.4 milion compared to the prior year of $2.7 milion.",
      "corrected": "Income was $9.4 milion compared to the prior year of $2.7 milion.",
      "suggestion_score": {
          "milion": [
              [
                  "million",
                  0.59422
              ],
              [
                  "billion",
                  0.24349
              ],
              ...
          ],
          "milion:1": [
              [
                  "billion",
                  0.65934
              ],
              [
                  "million",
                  0.26185
              ],
              ...
          ]
      }
  }
  ```



  - [ ] use cython for part of the code to improve performance ([#39](https://github.com/R1j1t/contextualSpellCheck/issues/39))
  - [ ] Improve metric for candidate selection ([#40](https://github.com/R1j1t/contextualSpellCheck/issues/40))
  - [ ] Add examples for other langauges ([#41](https://github.com/R1j1t/contextualSpellCheck/issues/41))
  - [ ] Update the logic of misspell identification (OOV) ([#44](https://github.com/R1j1t/contextualSpellCheck/issues/44))
  - [ ] better candidate generation (solved by [#44](https://github.com/R1j1t/contextualSpellCheck/issues/44)?)
  - [ ] add metric by testing on datasets
  - [ ] Improve documentation
  - [ ] Improve logging in code
  - [ ] Add support for Real Word Error (RWE) (Big Task)
  - [ ] add multi mask out capability

  <details><summary>Completed Task</summary>
  <p>

  - [x] specify maximum edit distance for `candidateRanking`
  - [x] allow user to specify bert model
  - [x] Include transformers deTokenizer to get better suggestions
  - [x] dependency version in setup.py ([#38](https://github.com/R1j1t/contextualSpellCheck/issues/38))

  </p>
  </details>



  If you like the project, please ⭑ the project and show your support! Also, if you feel, the current behaviour is not as expected, please feel free to raise an [issue](https://github.com/R1j1t/contextualSpellCheck/issues). If you can help with any of the above tasks, please open a [PR](https://github.com/R1j1t/contextualSpellCheck/pulls) with necessary changes to documentation and tests.



  If you are using contextualSpellCheck in your academic work, please consider citing the library using the below BibTex entry:

  ```bibtex
  @misc{Goel_Contextual_Spell_Check_2021,
  author = {Goel, Rajat},
  doi = {10.5281/zenodo.4642379},
  month = {3},
  title = {{Contextual Spell Check}},
  url = {https://github.com/R1j1t/contextualSpellCheck},
  year = {2021}
  }
  ```





  Below are some of the projects/work I referred to while developing this package

  1. Explosion AI.Architecture. May 2020. url:https://spacy.io/api.
  2. Monojit Choudhury et al. “How difficult is it to develop a perfect spell-checker? A cross-linguistic analysis through complex network approach”. In:arXiv preprint physics/0703198(2007).
  3. Jacob Devlin et al. BERT: Pre-training of Deep Bidirectional Transform-ers for Language Understanding. 2019. arXiv:1810.04805 [cs.CL].
  4. Hugging  Face.Fast Coreference Resolution in spaCy with Neural Net-works. May 2020. url:https://github.com/huggingface/neuralcoref.
  5. Ines.Chapter 3: Processing Pipelines. May 20202. url:https://course.spacy.io/en/chapter3.
  6. Eric Mays, Fred J Damerau, and Robert L Mercer. “Context based spellingcorrection”. In:Information Processing & Management27.5 (1991), pp. 517–522.
  7. Peter Norvig. How to Write a Spelling Corrector. May 2020. url:http://norvig.com/spell-correct.html.
  8. Yifu  Sun  and  Haoming  Jiang.Contextual Text Denoising with MaskedLanguage Models. 2019. arXiv:1910.14080 [cs.CL].
  9. Thomas  Wolf  et  al.  “Transformers:  State-of-the-Art  Natural  LanguageProcessing”. In:Proceedings of the 2020 Conference on Empirical Methodsin Natural Language Processing: System Demonstrations. Online: Associ-ation for Computational Linguistics, Oct. 2020, pp. 38–45. url:https://www.aclweb.org/anthology/2020.emnlp-demos.6.

  [1]: <http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=52A3B869596656C9DA285DCE83A0339F?doi=10.1.1.146.4390&rep=rep1&type=pdf>


pkgId: e00168661c1048fea452981aec116aa26ffd9da721dfcd2496439abf0df2e5ef
name: python-contextvars
arch: src
version: 2.4
epoch: 0
release: 1
summary: PEP 567 Backport
url: http://github.com/MagicStack/contextvars
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contextvars-2.4-1.src.rpm
checksum_type: sha256
description:
  This package implements a backport of Python 3.7 ``contextvars``
  module (see PEP 567) for Python 3.6.
  **Important:** at this moment this package does not provide an
  asyncio event loop with PEP 567 support yet.  Stay tuned for updates.


pkgId: 3ebc2dd718c0c9c0d2b58acabf91d6615842605bf262f85c67ddffb9b11a67f9
name: python-continuedev
arch: src
version: 0.1.104
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/continuedev/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-continuedev-0.1.104-1.src.rpm
checksum_type: sha256
description:
  This package contains the [Continue](https://github.com/continuedev/continue) server and core classes needed to build your own recipes.

  Continue is a Python library for automating repetitive sequences of software development tasks using language models. Using our VS Code extension, you can build, run, and refine these recipes as they natively interact with your codebase. Read the docs [here](https://continue.dev/docs) or download the VS Code extension [here](https://marketplace.visualstudio.com/items?itemName=Continue.continue).



  The Continue server acts as a bridge between the Continue React app and your IDE, running your recipes and acting on the codebase.

  Start it by running the following commands:

  1. `cd server`
  2. Make sure packages are installed with `poetry install`
     - If poetry is not installed, you can install with
     ```bash
     curl -sSL https://install.python-poetry.org | python3 -
     ```
     (official instructions [here](https://python-poetry.org/docs/#installing-with-the-official-installer))
  3. `poetry shell` to activate the virtual environment
  4. `python3 -m continuedev.server.main` to start the server

  Once you've validated that this works, you'll often want to use a debugger, in which case we've provided a launch configuration for VS Code in `.vscode/launch.json`. To start the debugger in VS Code, ensure that the workspace directory is the root of the `continue` repo, then press F5.

  > [!NOTE]
  > To start the debugger, you'll have to select the poetry Python interpreter
  > (`/path-to-poetry-venv/bin/python3`) in the bottom right of the VS Code window. If you
  > don't see this, you may have to install the [Python
  > extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python).



  `poetry run typegen` to generate JSONSchema .json files from the Pydantic types defined in the `models` directory.

  `poetry build` will output wheel and tarball files in `./dist`.



  See the `continuedev/libs/steps` folder for examples of writing a Continue step. See our documentation for tutorials.



  Open a [new GitHub Issue](https://github.com/continuedev/continue/issues/new) or comment on [an existing one](https://github.com/continuedev/continue/issues). Let us know what you would like to contribute, and we will help you make it happen!

  For more a more detailed contributing guide, see [CONTRIBUTING.md](../CONTRIBUTING.md).





  Recommended: Run this command to use SSH

  ```bash
  git clone git@github.com:continuedev/continue.git
  ```

  Alternative: Run this command to use HTTPS

  ```bash
  git clone https://github.com/continuedev/continue
  ```



  Run this command to use the install script

  ```bash
  cd continue/extensions/vscode/scripts && python3 install_from_source.py
  ```

  > [!IMPORTANT]
  > Ensure you have a Java Runtime Environment (JRE) installed. Verify this by typing `java
  -version` in your command prompt or terminal. If a version number appears, you're set.
  > If not, download and install a JRE from Oracle's website or through a package manager,
  > for example Homebrew.
  >
  > ```sh
  > brew install openjdk@11
  > ```



  - [Continue Server README](./README.md): learn about the core of Continue, which can be downloaded as a [PyPI package](https://pypi.org/project/continuedev/)
  - [VS Code Extension README](../extensions/vscode/README.md): learn about the capabilities of our extension—the first implementation of Continue's IDE Protocol—which makes it possible to use use Continue in VS Code and GitHub Codespaces
  - [Continue GUI README](../gui/): learn about the React app that lets users interact with the server and is placed adjacent to the text editor in any supported IDE
  - [Schema README](../schema/README.md): learn about the JSON Schema types generated from Pydantic models, which we use across the `server/` and `extensions/vscode/` directories
  - [Continue Docs README](../docs/README.md): learn how our [docs](https://continue.dev/docs) are written and built
  - [How to debug the VS Code Extension README](../extensions/vscode/src/README.md): learn how to set up the VS Code extension, so you can debug it


pkgId: 8c67e517f994cdc3aa0a1f55811d23a6eaa8721e79051ceed3cd9044a39294cb
name: python-continuous-delivery-scripts
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Continuous Delivery scripts to increase automation
url: https://github.com/ARMmbed/continuous-delivery-scripts
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-continuous-delivery-scripts-3.2.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (C) 2020-2023 Arm Limited or its affiliates and Contributors. All rights reserved.
  SPDX-License-Identifier: Apache-2.0
  -->


  ![Package](https://badgen.net/badge/Package/continuous-delivery-scripts/grey)
  [![Documentation](https://badgen.net/badge/Documentation/GitHub%20Pages/blue?icon=github)](https://armmbed.github.io/continuous-delivery-scripts)
  [![PyPI](https://badgen.net/pypi/v/continuous-delivery-scripts)](https://pypi.org/project/continuous-delivery-scripts/)
  [![PyPI - Status](https://img.shields.io/pypi/status/continuous-delivery-scripts)](https://pypi.org/project/continuous-delivery-scripts/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/continuous-delivery-scripts)](https://pypi.org/project/continuous-delivery-scripts/)
  [![Downloads](https://pepy.tech/badge/continuous-delivery-scripts)](https://pepy.tech/project/continuous-delivery-scripts)

  [![License](https://badgen.net/pypi/license/continuous-delivery-scripts)](https://github.com/ARMmbed/continuous-delivery-scripts/blob/master/LICENSE)
  [![Compliance](https://badgen.net/badge/License%20Report/compliant/green?icon=libraries)](https://armmbed.github.io/continuous-delivery-scripts/third_party_IP_report.html)

  [![Build Status](https://github.com/ARMmbed/continuous-delivery-scripts/actions/workflows/ci.yml/badge.svg)](https://github.com/ARMmbed/continuous-delivery-scripts/actions/workflows/ci.yml)

  [![Test Coverage](https://codecov.io/gh/ARMmbed/continuous-delivery-scripts/branch/main/graph/badge.svg?token=EAW9owYyjW)](https://codecov.io/gh/ARMmbed/continuous-delivery-scripts)
  [![Maintainability](https://api.codeclimate.com/v1/badges/41301e959f22986b7b2b/maintainability)](https://codeclimate.com/github/ARMmbed/continuous-delivery-scripts/maintainability)



  Project initially forked from [ARMmbed/mbed-tools-ci-scripts](https://github.com/ARMmbed/continuous-delivery-scripts) but modified so that it can be used for any projects and any languages.

  Continuous Delivery scripts for any projects:
  - Automated release flows (i.e. changelog generation, git tags, versioning)
  - third party IP auditing and reporting




  For release notes and a history of changes of all **production** releases, please see the following:

  - [Changelog](https://github.com/ARMmbed/continuous-delivery-scripts/blob/master/CHANGELOG.md)

  For a the list of all available versions please, please see the:

  - [PyPI Release History](https://pypi.org/project/continuous-delivery-scripts/#history)



  The version scheme used follows [PEP440](https://www.python.org/dev/peps/pep-0440/) and
  [Semantic Versioning](https://semver.org/). For production quality releases the version will look as follows:

  - `<major>.<minor>.<patch>`

  Beta releases are used to give early access to new functionality, for testing and to get feedback on experimental
  features. As such these releases may not be stable and should not be used for production. Additionally any interfaces
  introduced in a beta release may be removed or changed without notice. For **beta** releases the version will look as
  follows:

  - `<major>.<minor>.<patch>-beta.<pre-release-number>`



  It is recommended that a virtual environment such as [Pipenv](https://github.com/pypa/pipenv/blob/master/README.md) is
  used for all installations to avoid Python dependency conflicts.

  To install the most recent production quality release use:

  ```
  pip install continuous-delivery-scripts
  ```

  To install a specific release:

  ```
  pip install continuous-delivery-scripts==<version>
  ```



  Code documentation is available for the most recent
  production release here:

  - [GitHub Pages](https://armmbed.github.io/continuous-delivery-scripts)

  The package follows the [**Unix tools philosophy**](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/c1089.htm):

  > The tools philosophy was to have small programs to accomplish a particular task instead of trying to develop large monolithic programs to do a large number of tasks. To accomplish more complex tasks, tools would simply be connected together, using pipes.

  Therefore, it installs the following tools which can be used anywhere within a project/repository comprising a pyproject.toml file such as the [one defining this project](./pyproject.toml):
  * `cd-assert-news`: Asserts that the PR/Branch contains a news file describing the changes introduced
  * `cd-determine-version`: Returns the version of the tool
  * `cd-generate-news`: Generates a changelog file based on the news files present in the repository
  * `cd-get-config`: Returns project configuration values
  * `cd-tag-and-release`: Releases the project (Language specific actions are run, See [plugins](./continuous_delivery_scripts/plugins))
  * `cd-create-news-file`: Generates a news file
  * `cd-generate-docs`: Generates project Code documentation which can then be rendered by GitHub pages (See [docs folder](./docs))
  * `cd-generate-spdx`: Generates SPDX documents for the project (3rd party IP reporting/ OpenChain)
  * `cd-license-files`: Updates the Licence header and copyright to all the source code files



  The follow described the major aspects of the project structure:

  - `.github` - CI and GitHub configuration files.
  - `docs/` - Interface definition and usage documentation.
  - `examples/` - Usage examples.
  - `continuous-delivery-scripts/` - Python source files.
  - `news/` - Collection of news files for unreleased changes.
  - `tests/` - Unit and integration tests.



  - For interface definition and usage documentation, please see [GitHub Pages](https://armmbed.github.io/continuous-delivery-scripts).
  - For a list of known issues and possible workarounds, please see [Known Issues](./KNOWN_ISSUES.md).
  - To raise a defect or enhancement please use [GitHub Issues](https://github.com/ARMmbed/continuous-delivery-scripts/issues).



  - We are committed to fostering a welcoming community, please see our
    [Code of Conduct](./CODE_OF_CONDUCT.md) for more information.
  - For ways to contribute to the project, please see the [Contributions Guidelines](./CONTRIBUTING.md)
  - For a technical introduction into developing this package, please see the [Development Guide](./DEVELOPMENT.md)


pkgId: 021d8ea66e9e454356d48de21a371067a7000cd3aa85dafb77a4994c55d5921c
name: python-contique
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Numerical continuation of nonlinear equilibrium equations.
url: https://pypi.org/project/contique/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contique-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/adtzlr/contique/assets/5793153/86662194-2e2f-4dd6-b7de-5adf3270105d" height="80px"/>
    <p align="center">Numerical continuation of nonlinear equilibrium equations.</p>
  </p>

  [![PyPI version shields.io](https://img.shields.io/pypi/v/contique.svg)](https://pypi.python.org/pypi/contique/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/contique.svg)](https://pypi.python.org/pypi/contique/)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  ![Made with love in Graz](https://madewithlove.now.sh/at?heart=true&colorA=%233b3b3b&colorB=%231f744f&text=Graz)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7931300.svg)](https://doi.org/10.5281/zenodo.7931300)
  [![codecov](https://codecov.io/gh/adtzlr/contique/branch/main/graph/badge.svg?token=CXKRL8TLQY)](https://codecov.io/gh/adtzlr/contique)

  Contique is a Python 3.7+ package that provides methods for numeric continuation. It depends on
  - `numpy` (for arrays) and
  - `scipy` (check if matrix is sparse and sparse solver).

  > **Note**
  > The original motivation was to create a generalized standalone package with the built-in numeric continuation methods taken from the nonlinear truss analysis package [trusspy](https://github.com/adtzlr/trusspy).



  A solution curve for `(n)` equilibrium equations `fun` in terms of `(n)` unknowns `x` and a load-proportionality-factor `lpf` should be found by numeric continuation from an initial equilibrium state `fun(x0, lpf0) = 0`. Contique's numeric continuation method is best classified as a

  - **component-based continuation** with an adaptive
  - **magnitude-based control-component switching**.


  <a href="https://github.com/adtzlr/contique/blob/main/tests/test_archimedean_spiral.py"><img src="https://github.com/adtzlr/contique/assets/5793153/6b38c783-bdfc-470a-8a66-82a3ca663407" width="75%"></a>

  Fig. 1 [Archimedean spiral](https://en.wikipedia.org/wiki/Archimedean_spiral) equation solved with [contique](https://github.com/adtzlr/contique/blob/main/tests/test_archimedean_spiral.py)


  The `lpf` value is appended to the unknows `x` which gives the so-called extended unknowns `y = [x, lpf]`. One additional control equation is added to the equilibrium equations to ensure `(n+1)` equations in terms of `(n+1)` extended unknowns (see next section). This reduces the solution to a point on the initial solution curve.


  The control equation is defined as follows: First, a needle-vector with dimension `(n+1)` is created and filled with zeros `needle = 0`. For a given initial signed control component `j` the needle is positioned at `needle[|j|] = 1`. The maximum allowed values per component are calculated as `ymax = y0 + np.sign(j) dymax`. The control equation is finally formulated as `f(y) = needle.T (y - ymax)`.


  The numeric solution process is divided into three main parts:

  - **Step**
      + Cycle
          * *Iteration* (...of a Newton-Rhapson root method)

  As the name implies, a **Step** tries to find the extended unknowns for the next step forward of the equilibrium state. For each Cycle, the initial control component has to be evaluated first (see comment below). The additional control equation is evaluated with this initial control component. The generated extended equilibrium equations in terms of the extended unknows are now solved with the help of a root method (Newton-Rhapson *Iterations*). The solution of the root method `dy` is further normalized as `dy/dymax` and the final control component is evaluated as `j = |j| sign((dy/dymax)[|j|])` with `|j| = argmax(|dy/dymax|)`. If the control component changed, another Cycle is performed with the initial control component being now the final control component of the last cycle. This Cycle-loop is repeated until the control component does not change anymore.

  A note on the pre-evaluation of the initial control component of a **Step**: This is performed by the linear solution of the extended equilibrium equations. It is equal to the result of the first *Iteration* of the Newton-Rhapson root method.


  A given set of equilibrium equations in terms of `x` and `lpf` (a.k.a. load-proportionality-factor) should be solved by numeric continuation of a given initial solution.


  ```python
  def fun(x, lpf, a, b):
      return np.array(
          [-a * np.sin(x[0]) + x[1] ** 2 + lpf, -b * np.cos(x[1]) * x[1] + lpf]
      )
  ```

  with its initial solution
  ```python
  x0 = np.zeros(2)
  lpf0 = 0.0
  ```

  and function parameters
  ```python
  a = 1
  b = 1
  ```



  ```python
  Res = contique.solve(
      fun=fun,
      x0=x0,
      args=(a, b),
      lpf0=lpf0,
      dxmax=0.1,
      dlpfmax=0.1,
      maxsteps=75,
      maxcycles=4,
      maxiter=20,
      tol=1e-8,
      overshoot=1.05,
  )
  ```

  For each `step` a summary is printed out per `cycle`. This contains an information about the control component at the beginning and the end of a cycle as well as the norm of the residuals along with needed Newton-Rhapson `iterations` per `cycle`. As an example the ouput of some interesting `steps` 31-33 and 38-40 are shown below. The last column contains messages about the solution. On the one hand, in `step` 32, `cycle` 1 the control component changed from `+1` to `-2`, but the relative overshoot on the final control component `-2` was inside the tolerated range of `overshoot=1.05`. Therefore the solver proceeds with `step` 33 without re-cycling `step` 32. On the other hand, in `step` 39, `cycle` 1 the control component changed from `-2` to `-1` and this time the overshoot on the final control component `-1` was outside the tolerated range. A new `cycle` 2 is performed for `step` 39 with the new control component `-1`.

  ```markdown
  |Step,C.| Control Comp. | Norm (Iter.#) | Message     |
  |-------|---------------|---------------|-------------|

  (...)

  |  31,1 |   +1  =>   +1 | 7.6e-10 ( 3#) |             |
  |  32,1 |   +1  =>   -2 | 1.7e-14 ( 4#) |tol.Overshoot|
  |  33,1 |   -2  =>   -2 | 4.8e-12 ( 3#) |             |

   (...)

  |  38,1 |   -2  =>   -2 | 9.2e-12 ( 3#) |             |
  |  39,1 |   -2  =>   -1 | 1.9e-13 ( 3#) | => re-Cycle |
  |     2 |   -1  =>   -1 | 2.3e-13 ( 4#) |             |
  |  40,1 |   -1  =>   -1 | 7.9e-09 ( 3#) |             |

  (...)
  ```

  Next, we have to assemble the results

  ```python
  X = np.array([res.x for res in Res])
  ```

  and plot the solution curve.

  ```python
  import matplotlib.pyplot as plt

  plt.plot(X[:, 0], X[:, 1], "C0.-")
  plt.xlabel("$x_1$")
  plt.ylabel("$x_2$")
  plt.plot([0], [0], "C0o", lw=3)
  plt.arrow(
      X[-2, 0],
      X[-2, 1],
      X[-1, 0] - X[-2, 0],
      X[-1, 1] - X[-2, 1],
      head_width=0.075,
      head_length=0.15,
      fc="C0",
      ec="C0",
  )
  plt.gca().set_aspect("equal")
  ```

  <a href="https://github.com/adtzlr/contique/blob/main/tests/test_sincos.py"><img src="https://github.com/adtzlr/contique/assets/5793153/20fb6415-d226-4859-b818-4f79194ba1e2" width="75%"></a>

  Fig. 2 Solution states of [equilibrium equations](https://github.com/adtzlr/contique/blob/main/tests/test_sincos.py) solved with contique


  All notable changes to this project will be documented in [this file](CHANGELOG.md). The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  Numerical continuation of nonlinear equilibrium equations. Copyright (C) 2023  Andreas Dutzler  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 <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  contique  Copyright (C) 2023  Andreas Dutzler This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: b8c2e26ac10edd5e8db151faad5ae23d47925b3cecda3d2fdd2d770af22636dc
name: python-contoml
arch: src
version: 0.32
epoch: 0
release: 1
summary: Consistent TOML for Python
url: https://github.com/Jumpscale/python-consistent-toml
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contoml-0.32-1.src.rpm
checksum_type: sha256
description:
  A TOML serializer/deserializer for Python that tries its best to preserve order of table mappings, formatting of source file, and comments during a deserialize/update/serialize job. This is achieved by preserving the parsed/constructed TOML data structures as lexical tokens internally and having the data manipulations performed directly on the tokens.


pkgId: 48910eb2eeb2f9fc9fb2d4279f6ccff6585166f4df18f44d36e9a1a067b7949e
name: python-contours
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Contour calculation with Matplotlib.
url: https://github.com/ccarocean/python-contours
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contours-0.0.2-1.src.rpm
checksum_type: sha256
description:
  The `contours` package exposes Matplotlib's contour generators to the user
  providing an equivalent of MATLAB's ``contourc`` function.  This is done for
  grids (including curvilinear) as well as unstructured data via Delaunay
  triangulation (**FUTURE**).
  Regular contours can be returned as `NumPy`_ arrays or as `Shapely`_
  LineStrings and LinearRings.  Filled contours can be returned as `NumPy`_
  arrays or as `Shapely`_ Polygons.
  Contour calculation without plotting is currently an open issue `#367`_ for
  Matplotlib.  In that discussion, the type of hackery done in this library is
  discouraged by the Matplotlib developers.  As of this writing there has been no
  decision as to whether exposing contour calculations is a feature that should
  be included in Matplotlib or not.  If such a refactoring in Matplotlib ever
  takes place, this library will be refactored to avoid using Matplotlib's
  internal components.


pkgId: 01857f3e757f8754e4dd331f66e73632cea2219a467b898f3c9f9e92228c83ed
name: python-contract-deploy-tools
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Compile, test and deploy smart contracts
url: https://github.com/trustlines-protocol/contract-deploy-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contract-deploy-tools-0.11.1-1.src.rpm
checksum_type: sha256
description:
  Tools around compiling, deploying and testing smart contracts on an ethereum chain with python.


  ```bash
  pip install -r dev-requirements.txt -e .
  ```


  ```bash
  pytest
  ```


pkgId: c6d1a5db24f2d75ba447ffc2c312234c7cd90b8bee74ade477feb5a5943e1ee0
name: python-contracts-lib-py
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: 🐳 Library including all the common functionalities used in Python projects
url: https://github.com/nevermined-io/contracts-lib-py
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contracts-lib-py-1.0.4-1.src.rpm
checksum_type: sha256
description:
  [![banner](https://raw.githubusercontent.com/nevermined-io/assets/main/images/logo/banner_logo.png)](https://nevermined.io)



  > Wraps Nevermined contracts and web3 functions.
  > [nevermined.io](https://nevermined.io)

  [![PyPI](https://img.shields.io/pypi/v/contracts-lib-py.svg)](https://pypi.org/project/contracts-lib-py/)




  This project is based in the [Ocean Protocol Keeper-py-lib](https://github.com/oceanprotocol/keeper-py-lib). It keeps the same Apache v2 License and adds some improvements.




  ```text
  Copyright 2020 Keyko GmbH.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```


pkgId: bc5670298c496a9fac6bf51d1b3dac3ac2cd3ce1151912b87d3eb96850df76a1
name: python-contrast-agent-lib
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python interface to the contrast agent lib
url: https://pypi.org/project/contrast-agent-lib/
rpm_license: CONTRAST SECURITY (see LICENSE.txt)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contrast-agent-lib-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Core library for shared Contrast Agent functionality.


  For the most up-to-date documentation on the Python Agent please see
  [Contrast Docs](https://docs.contrastsecurity.com/en/python.html)


pkgId: b98b167a6275d9d5070827ea85beaf9bfa8bb1ef4bc676445e842d4980e2acdc
name: python-contrast-fireball
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Python interface to the shared Contrast Fireball library
url: https://pypi.org/project/contrast-fireball/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contrast-fireball-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Cross-platform Contrast Agent reporting library.

  For the most up-to-date documentation on the Python Agent please see
  [Contrast Docs](https://docs.contrastsecurity.com/en/python.html).

rpm_license:
  Copyright: 2024 Contrast Security, Inc Contact: support@contrastsecurity.com License: Commercial  NOTICE: This Software and the patented inventions embodied within may only be used as part of Contrast Security’s commercial offerings. Even though it is made available through public repositories, use of this Software is subject to the applicable End User Licensing Agreement found at https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed between Contrast Security and the End User. The Software may not be reverse engineered, modified, repackaged, sold, redistributed or otherwise used in a way not consistent with the End User License Agreement.


pkgId: 4c12c99445b26ca62b3fd3633ee34a873d718efbc035c425d3c5beae4c829cdc
name: python-control
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Python Control Systems Library
url: https://pypi.org/project/control/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-control-0.10.1-1.src.rpm
checksum_type: sha256
description:
  The Python Control Systems Library is a Python module that implements basic
  operations for analysis and design of feedback control systems.


pkgId: 5a941ac18b4e9d39f78989e542eec58d5ae79295c9a2faacc966cf1829a08162
name: python-control-lab-ly
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Lab Equipment Automation Package
url: https://github.com/kylejeanlewis/control-lab-le
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-control-lab-ly-1.3.2-1.src.rpm
checksum_type: sha256
description:
  For more advanced uses, Control.lab.ly provides a host of tools to streamline the development of lab equipment automation. This includes setting up configuration files and adding plugin drivers.

  ```python
  import controllably as lab
  ```
  Optionally, you can set the safety policy for the session. This feature allows the user to prevent collisions before each movement is made. The safety policy has to be assigned before importing any of the `Mover` objects.
  ```python
  lab.set_safety('high')  # Notifies; Pauses for input before every move action
  lab.set_safety('low')   # Notifies; Waits for countdown before every move action
  lab.set_safety(None)    # Carries out movement actions without delay

  ```

  1. [Setups](#1-creating-a-new-setup)
  2. [Decks](#2-managing-a-deck)
  3. [Addresses](#3-managing-project-addresses)
  4. [Plugins](#4-using-plugins)

  Create a `/configs/MySetup` folder that holds the configuration files for the setup, which includes `config.yaml` and `layout.json`.
  ```python
  lab.create_setup(setup_name = "MySetup")
  ```

  This file stores the configuration and calibration values for your devices.
  ```yaml
  MyDevice:                                       # device name
    module: Move                                  # top-level category
    class: Cartesian.Ender                        # device class
    settings:
      port: COM1                                  # serial port address
      setting_A: {'tuple': [300,0,200]}           # use keys to define the type of iterable
      setting_B: {'array': [[0,1,0],[-1,0,0]]}    # only tuple and np.array supported
  ```
  > Each device configuration starts with the device name, then the following parameters:\
  > `module`: top-level category (such as Make, Measure, Move,Transfer, View)\
  > `class`: point to specific subclass using dot notation\
  > `settings`: various initialisation settings\
  > *See the* [**guide**](#view-documentation) *for more details on these parameters*
  Compound devices are similarly configured.
  ```yaml
  MyCompoundDevice:                         # compound device name
    module: Compound
    class: LiquidMover.LiquidMoverSetup
    settings:                               # settings for your compound device
      setting_C: True
      component_config:                     # nest component configuration settings here
        MyFirstDevice:                      # component device name
          module: Transfer
          class: Liquid.SyringeAssembly
          settings:                         # settings for your component device
            port: COM22
            setting_D: 2
        MySecondDevice:                     # component device name
          module: Mover
          class: Jointed.Dobot.M1Pro
          settings:                         # settings for your compound device
            ip_address: '192.0.0.1'
  ```
  > The configuration values for the component devices are nested under the `component_config` setting of the compound device.
  Lastly, you can define shortcuts (or nicknames) to quickly access the components of compound devices.
  ```yaml
  SHORTCUTS:
    First: 'MyCompoundDevice.MyFirstDevice'
    Second: 'MyCompoundDevice.MySecondDevice'
  ```
  > A different serial port address or camera index may be used by different machines for the same device.\
  *See* [**Section 3**](#3-creating-a-new-project) *to find out how to manage the different addresses used by different machines.*

  This file stores the layout configuration of your physical workspace, also known as a `Deck`.\
  *See* [**Section 2**](#2-managing-a-deck) *on how to load this information into the setup.*
  *Optional: if your setup does not involve moving objects around in a pre-defined workspace,  a layout configuration may not be required*
  > This package uses the same Labware files as those provided by [Opentrons](https://opentrons.com/), which can be found [here](https://labware.opentrons.com/), and custom Labware files can be created [here](https://labware.opentrons.com/create/). Labware files are JSON files that specifies the external and internal dimensions of a Labware block / object.
  ```json
  {
    "reference_points":{
      "1": [11.1,22.2,33.3],
      "2": [44.4,55.5,66.6],
      "3": [77.7,88.8,99.9]
    },
    "slots":{
      "1": {
        "name": "MyLabware01",
        "exclusion_height": -1,
        "filepath": "MyREPO/.../MyLabware01.json"
      },
      "2": {
        "name": "MyLabware02",
        "exclusion_height": 0,
        "filepath": "MyREPO/.../MyLabware02.json"
      },
      "3": {
        "name": "MyLabware03",
        "exclusion_height": 10,
        "filepath": "MyREPO/.../MyLabware03.json"
      }
    }
  }
  ```
  > In `reference_points`, the bottom-left coordinates of each slot on the deck are defined. Slots are positions where Labware blocks may be placed.
  > In `slots`, the `name` of the Labware and the `filepath` to the JSON file containing Labware details are defined. The filepath starts with the name of the repository's base folder.\
  >\
  > The `exclusion_height` is the height (in mm) above the dimensions of the Labware block to steer clear from when performing movement actions. Values less than 0 means the Labware is not avoided.\
  >\
  > *(Note: Labware avoidance only applies to final coordinates (i.e. destination). Does not guarantee collision avoidance when using point-to-point move actions. Use* `safeMoveTo()` *instead.)*

  The initialisation of the setup occurs when importing `setup` from `configs.MySetup`. With `setup`, you can access all the devices that you have defined in [**Section 1.1**](#11-configyaml).
  ```python


  from pathlib import Path
  import sys
  REPO = 'MyREPO'
  ROOT = str(Path().absolute()).split(REPO)[0]
  sys.path.append(f'{ROOT}{REPO}')

  from configs.MySetup import setup
  setup.MyDevice
  setup.First
  ```

  *Optional: if your setup does not involve moving items around in a pre-defined workspace,  a* `Deck` *may not be required*

  To load a `Deck` from the layout file, use the `loadDeck()` function of a `Mover` object (or its subclasses).
  ```python
  from configs.MySetup import setup, LAYOUT_FILE
  setup.Mover.loadDeck(LAYOUT_FILE)
  ```
  > `LAYOUT_FILE` contains the details that has been defined in `layout.json` (see [**Section 1.2**](#12-layoutjson))

  To load a `Labware` onto the deck, use the `loadLabware()` method of the `Deck` object.
  ```python
  setup.Mover.deck.loadLabware(...)
  ```
  > This package uses the same Labware files as those provided by [Opentrons](https://opentrons.com/), which can be found [here](https://labware.opentrons.com/), and custom Labware files can be created [here](https://labware.opentrons.com/create/). Labware files are JSON files that specifies the external and internal dimensions of a Labware block / object.

  A `/configs` folder will have been created in the base folder of your project repository to store all configuration related files from which the package will read from, in [**Section 1**](#1-creating-a-new-setup). A template of `registry.yaml` has also been added to the `/configs` folder to manage the machine-specific addresses of your connected devices (e.g. serial port and camera index).
  ```yaml

  '012345678901234':              # insert your machine's 15-digit ID here
      cam_index:                  # camera index of the connected imaging devices
        __cam_01__: 1             # keep the leading and trailing double underscores
        __cam_02__: 0
      port:                       # addresses of serial ports
        __MyDevice__: COM1        # keep the leading and trailing double underscores
        __MyFirstDevice__: COM22
  ```
  > Use the `Helper.get_node()` function to get the 15-digit unique identifier of your machine\
  > Use the `Helper.get_port()` function to get the serial port addresses of your connect devices
  ```python
  lab.Helper.get_node()           # Get your machine's ID (15-digit)
  lab.Helper.get_ports()          # Get the port addresses of connected devices
  ```
  Afterwards, change the value for the serial port address in the `config.yaml` file to match the registry.
  ```yaml

  MyDevice:
    module: Move
    class: Cartesian.Ender
    settings:
      port: __MyDevice__          # serial port address
  ```

  *Optional: if drivers for your hardware components are already included, plugins may not be required*
  User-defined plugins can be easily written and integrated into Control.lab.ly. All available classes and functions can be found in `lab.modules`.
  ```python
  lab.guide_me()                              # Use guide to view imported objects
  lab.modules.at.Make.Something.Good.MyClass  # Access the class
  ```

  You can import the class and register the object using the `Factory.register()` function.
  ```python
  from my_module import MyClass
  lab.Factory.register(MyClass, "Make.Something.Good")
  ```

  Alternatively, you can automatically register all Classes and Functions in a Python module just by importing it.
  > 1. Declare a `__where__` global variable to indicate where to register the module
  > 2. At the end of the .py file, import and call  the `include_this_module()` function
  ```python

  __where__ = "Make.Something.Good"               # Where to register this module to
  def MyClass:                                    # Main body of code goes here
  def my_function:
  from controllably import include_this_module    # Registers only the Classes and Functions
  include_this_module()                           # defined above in this .py file
  ```
  The Classes and Functions in the module will be registered when you import the module.
  ```python

  from my_module import MyClass, my_function


pkgId: 2c22f43d8b839720980417d96eeea1a1d31c21f29980cc65751dc6dc69db4c66
name: python-controlSBML
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Control analysis of SBML models
url: https://github.com/ModelEngineering/controlSBML
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlSBML-1.2.1-1.src.rpm
checksum_type: sha256
description:
  ``controlSBML`` is a python packag that assists with control engineering of biological systems that are characterized by models in
   the [Systems Biology Markup Language (SBML)](https://co.mbine.org/standards/sbml), a community standard for representing
  models of biological models, especially chemical reaction networks.
  ``controlSBML`` provides the following:
    * Read SBML models, viewing candidate inputs, and outputs, and running simulations.
    * System identification, including the creation of (SISO) transfer function objects from the python control systems library
    * Creating Antimony simulations of closed loop systems
    * Design of closed loop systems

  Examples of usage are in this [directory](https://github.com/ModelEngineering/controlSBML/tree/main/examples)


  ``pip install controlSBML``

  To find the current version:
  ```
  import controlSBML as ctl
  ctl.__version__
  ```


  * 1.2.1 5/23/2024
      * Eliminated the save_path feature since it conflicted with usage in colab.
  * 1.2.0 5/22/2024
      * Implemented differential control
      * Extended noise model to include lognormal distribution, offset, and slope
      * Implemented several examples, some of which are based on student projects
      * Two algorithms for fitting. gpz fits the transfer function in order by gain (g), poles (p), zeroes (z). poly fits a polynomial in s to the simulations.
  * 1.1.03 1/20/2024
      * Better error checking
      * API uses parameter names kI, kP, kF
  * 1.1.02 12/27/2023
      * Fix bug in dependencies. Update header documentation.
  * 1.1.01 12/27/2023
      * Complete change in the architecture. Instead of using NonlinearIOSystems in the python control package, controlSBML generates Antimony code to implement staircase functions and closed loops.
      * Creation of a consistent API.
  * 1.0.11 3/1/2023
      * Ensure that state variables are never negative.
  * 1.0.10
      * Fixed bug with unequally spaced times
      * Fixed bug so can start a simulate at a time other than 0 and the correct initial state is obtained.
  * 1.0.9 2/14/2023
      * Use temporary directory for plots created in tests
  * 1.0.8 2/14/2023
      * Avoid error if Jacobian cannot be calculated.
      * Better handling of warnings
  * 1.0.7 2/11/2023
      * Add missing dependency (lmfit)
  * 1.0.6  2/11/2023
      * ControlSBML.makeSISOTransferFunctionBuilder creates a SISOTransferFunctionBuilder object. The plotStaircaseResponse method of SISOTransferFuntionBuilder indicates the controlability of an input for the output. fitTransferFunction fits a transfer function to the outputs produced by a staircase input.
      * plotStaircaseResponse shows effect of a staircase input on outputs
      * Remove cruft from effector_dct
      * Added plot option writefig which takes arguments, True, False, str (path)
  * 1.0.5  1/22/2023
      * Fix bugs in NonlinearIOSystem relating to states and calculations in updfcn.
      * Changes to documentation
  * 1.0.4
      * Fix bug so that makeStateSpace honors the time argument
      * Updated Sphinx documentation
      * Fix bug with __version__
  * 1.0.3
      * Fix bug with file path in _version
  * 1.0.1
      * src directory contains all pcakages
  * 1.0.0
      * Redefined inputs as species adjustment (positive or negative)
      * ControlSBML.equals has an option to do a "quick check"
      * Deprecated the use of an effector dictionary
  * 0.2.23 12/18/2022
      * Updates for using toml files
  * 0.2.22
    * IOSystemFactor.makeStateFilter creates a vector of filters between 2 systems
    * SISOClosedLoopSystem.makeFullStateController creates multiple filters if kf != 0
  * 0.2.21 5/30/2022
    * NonlinearIOSystem creates a logger.
    * SISOClosedLoopSystem.makeFullStateSystem has option for filters
    * Changed legend of step respoinse plot to use "reference" instead of "step"
  * 0.2.20 5/27/2022
    * Fix bug in SISOClosedLoopSystem.evaluateControllability because scipy didn't
      handle nan values.
  * 0.2.19 5/27/2022
    * Fix bug in SISOClosedLoopSystem.evaluateControllability because scipy didn't
      handle nan values.
  * 0.2.18 5/26/2022
    * Fix small bug
  * 0.2.17 5/26/2022
    * Deleted the callback_log implemented in 0.2.14.
  * 0.2.16 5/24/2022
    * Refactored SISOClosedLoopSystem
    * Implemented SISOClosedLoopSystem.makeFullStateController
    * Fixed bug with makePIDController where ki, kd are ineffective.
  * 0.2.15 5/21/2022
    * Fix bug in reverting the semantics of control input to be setting the species
      as a static.
  * 0.2.14  5/11/2022
    * Provide callback for each manufactured IOsystemFactory
    * Reverted semantics of control input to a NonlinearIOSystem to be
  setting the value rather than adding or subtracting a value.
  * 0.2.13 5/9/2022
    * SISOClosedLoopSystem provides a way to construct a closed loop system
      for an SBML model. The system has a PID controller and a filter.
    * IOSysemFactory has a log
  * 0.2.12 5/3/2022
    * IOSystemFactory creates IOSystem objects for Adder, Multiplier,
      Filter, PIDController, Sinusoid, Constant, Passthru
    * State inputs add to state, not replace the state value.
  * 0.2.11 4/25/2022
    * Fix bug in calculating transfer function that incorrectly considered state
  * 0.2.9 4/19/2022
    * Fluxes can be outputs
    * Construction of transfer function includes atol option for simplification
  * 0.2.8 4/17/2022
    * Added options to plotTrueModel
    * Updated Using ControlSBML with an example of doing feedback
  * 0.2.7 4/11/2022
    * Species can be inputs
    * makeStateSpace, makeTransferFunction have timepoint argument
  * 0.2.6 4/10/2020
    * Default for constructor: is_reduced=False
    * makeTransferFunction
  * 0.2.5 4/8/2022
    * Improve performance by not recalculating Jacobian
    * Fix bugs related to implementation of is_reduced as applied on NonlinearIOSystem
  * 0.2.4 3/31/2024 - Create reduced A matrix
    * mat2Df - fixed bug with printing column names
    * Create reduced A matrix for makeStateSpace so that A is non-singular
      Default output_names is all floating species
  * 0.2.3, 3/22/2022 - Bug fix for mat2DF
  * 0.2.2, 3/22/2022 - Bug fix
  * 0.2.1, 3/22/2022 - Bug fix
  * 0.2.0, 3/22/2022 - Version for class
    * ppMat - pretty print a matrix
    * plotMat - display a heatmap for a matrix
    * mat2TS - convert a matrix to a timeseries
    * mat2DF - convert a matrix to a dataframe
  * 0.1.6, 3/16/2022
    * ``Using-Control-SBML.ipynb`` has an example of doing feedback control design
  with ``controlSBML``.
    * ``control.NonlinearIOSystem`` wraps an SBML model. Can be used
      in the construction of systems using ``control.interconnect`` and in simulations using ``control.input_output_response``. One caveat is that this may work poorly for models implemented as SBML rate rules.
  * 0.1.5, 3/5/2022.
    * More options for plotting and simulations
    * plotBode
    * Inputs are identified by reaction Ids
  * 0.1.3, 2/13/2022. First release.

rpm_license:
  MIT License  Copyright (c) 2022 Joseph Hellerstein  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.


