# packages

pkgId: bb35002f2478fd6f6697b590b111bef83e19da564e1abad41ba3731c768383d1
name: python-3
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: Hey
url: https://abranhe.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: vm-2p16g.taishan200-2280-2s48p-256g--a60-1.compass-ci.net
location_href: Packages/python-3-0.0.0-1.src.rpm
checksum_type: sha256
description:
  |[![Carlos Abraham Logo](https://avatars3.githubusercontent.com/u/21347264?s=50&v=4)](https://19cah.com)|
  | :-: |
  | [Carlos Abraham](https://github.com/abranhe) |


pkgId: 85c17c8b8616994127687a9a821ce226b00d529d32f9b332b05d00c7bfccd4f4
name: python-310-notebook
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A JupyterLab extension.
url: https://github.com/pooriyapfn/jupyterlab_extension.git
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: vm-2p16g.taishan200-2280-2s48p-256g--a31-1.compass-ci.net
location_href: Packages/python-310-notebook-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Github Actions Status](https://github.com/pooriyapfn/jupyterlab_extension.git/workflows/Build/badge.svg)](https://github.com/pooriyapfn/jupyterlab_extension.git/actions/workflows/build.yml)
  A JupyterLab extension.



  - JupyterLab >= 3.0



  To install the extension, execute:

  ```bash
  pip install 310_notebook
  ```



  To remove the extension, execute:

  ```bash
  pip uninstall 310_notebook
  ```





  Note: You will need NodeJS to build the extension package.

  The `jlpm` command is JupyterLab's pinned version of
  [yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
  `yarn` or `npm` in lieu of `jlpm` below.

  ```bash



  pip install -e .

  jupyter labextension develop . --overwrite

  jlpm build
  ```

  You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.

  ```bash

  jlpm watch

  jupyter lab
  ```

  With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).

  By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:

  ```bash
  jupyter lab build --minimize=False
  ```



  ```bash
  pip uninstall 310_notebook
  ```

  In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
  command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
  folder is located. Then you can remove the symlink named `310_notebook` within that folder.





  This extension is using [Jest](https://jestjs.io/) for JavaScript code testing.

  To execute them, execute:

  ```sh
  jlpm
  jlpm test
  ```



  This extension uses [Playwright](https://playwright.dev/docs/intro/) for the integration tests (aka user level tests).
  More precisely, the JupyterLab helper [Galata](https://github.com/jupyterlab/jupyterlab/tree/master/galata) is used to handle testing the extension in JupyterLab.

  More information are provided within the [ui-tests](./ui-tests/README.md) README.



  See [RELEASE](RELEASE.md)


pkgId: decde267af0a99520ebbc7f347d4ca3702b734b3ec531210954168d3b1b8d70f
name: python-a816
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: 65c816 patching assembler (Super Famicom)
url: https://pypi.org/project/a816/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a816-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Another 65c816 assembler




  ```
  $ a816 --help
  usage: x816 [-h] [--verbose] [-o OUTPUT_FILE] [-f FORMAT] [-m MAPPING] [--copier-header] [--dump-symbols] [-D KEY=VALUE [KEY=VALUE ...]] input_file

  x816 usage

  positional arguments:
    input_file            The asm file to assemble.

  options:
    -h, --help            show this help message and exit
    --verbose             Displays all log levels.
    -o OUTPUT_FILE, --output OUTPUT_FILE
                          Output file
    -f FORMAT             Output format
    -m MAPPING            Address Mapping
    --copier-header       Adds 0x200 address delta corresponding to copier header in ips writer.
    --dump-symbols        Dumps symbol table
    -D KEY=VALUE [KEY=VALUE ...], --defines KEY=VALUE [KEY=VALUE ...]
                          Defines symbols.
  ```

  or directly from python code:



  ```python
  from a816.program import Program

  def build_patch(input, output):
      program = Program()
      program.assemble_as_patch(input, output)
      program.resolver.dump_symbol_map()
  ```





  ```
  adc, and, asl, bcc, bcs, beq, bit, bmi, bne, bpl, bra, brk, brl, bvc, bvs, clc, cld, cli, clv, cmp, cop, cpx, cpy, db, dec, dex, dey, eor, inc, inx, iny, jml, jmp, jsl, jsr, lda, ldx, ldy, lsr, mvn, mvp, nop, ora, pea, pei, per, pha, phb, phd, phk, php, phx, phy, pla, plb, pld, plp, plx, ply, rep, rol, ror, rti, rtl, rts, sbc, sec, sed, sei, sep, sta, stp, stx, sty, stz, tax, tay, tcd, tcs, tdc, trb, tsb, tsc, tsx, txa, txs, txy, tya, tyx, wai, xba, xce
  ```



  ```ca65
  ; define a macro
  .macro test(var_1, var_2) {
      lda.w var_1 << 16 + var_2
  }

  ; use that macro
  test(0x10, 0x10)

  ; should expand that way
  lda.w 0x10 << 16 + 0x10

  ; code generated
  lda.w 0x1010
  ```




  ```ca65
  *=0x008000
      jsr.l _intro
  ```




  ```ca65
  some_address = 0x54
  {
      lda.b some_address
      beq no_action
      ; this label is only visible inside this scope
      no_action:
  }
  ```



  ```ca65
  *=0x009000
  named_scope {
     addr = 0x1234
     youhou_text:
     .text 'youhou'
     .db 0
     yaha_text:
     .text 'yaha'
     .db 0
  }

  *=0x019A52
  	load_system_menu_text_pointer(named_scope.youhou_text)

  *=0x019A80
  	load_system_menu_text_pointer(named_scope.yaha_text)

  ```


pkgId: f6e55a0de3ab85f56d7927ba41b1b0617043935b0a56046f1c02275e39943d04
name: python-aaaa
arch: src
version: 1.0
epoch: 0
release: 1
summary: Alphabetize output filenames
url: http://github.com/sgrieve/aaaa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aaaa-1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/sgrieve/aaaa.svg?branch=master)](https://travis-ci.org/sgrieve/aaaa) [![Coverage](https://img.shields.io/codecov/c/github/sgrieve/aaaa)](https://codecov.io/gh/sgrieve/aaaa) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aaaa) ![PyPI - License](https://img.shields.io/pypi/l/aaaa)

  Have you ever been creating an animated plot by saving a series of images and joining them together? The obvious way to name these frames would be using numbers:

  ```python
  for i in range(15):
      plt.savefig('{}.png'.format(i))
  ```

  But many operating systems will order these files as follows:

  ```bash
  0.png
  1.png
  10.png
  11.png
  12.png
  13.png
  14.png
  2.png
  3.png
  4.png
  5.png
  6.png
  7.png
  8.png
  9.png
  ```

  Thereby screwing up the order of your animation.

  This is where `aaaa` (pronounced like a scream) comes in! `aaaa` has a single class which creates an iterator that yields an alphabetical sequence `aa`, `ab`, `ac`, etc. So we can change our above example:

  ```python
  from aaaa import aaaa

  fname = aaaa()

  for i in range(15):
      plt.savefig('{}.png'.format(next(fname)))
  ```

  Which will preserve the order of the files in your operating system:

  ```bash
  aa.png
  ab.png
  ac.png
  ad.png
  ae.png
  af.png
  ag.png
  ah.png
  ai.png
  aj.png
  ak.png
  al.png
  am.png
  an.png
  ao.png
  ```

  File sorting can differ between operating systems, sometimes with [serious results](https://arstechnica.com/information-technology/2019/10/chemists-discover-cross-platform-python-scripts-not-so-cross-platform/).




  `aaaa` has no dependences and is tested on Python 3.5 through 3.8 and it can be installed via pip:

  ```bash
  pip install aaaa
  ```



  There are two ways to use `aaaa`. Firstly, you can loop directly over an `aaaa` instance, until there are no items left (in this case the last value of name will be `zz`):

  ```python
  from aaaa import aaaa

  names = aaaa()

  for name in names:
      print(name)

  ```

  Or, you can use the `next()` operator to only get as many values as you need:

  ```python
  from aaaa import aaaa

  names = aaaa()

  for i in range(10):
      print(next(names))

  ```

  The default length of an output from `aaaa` is 2 characters long - this will allow you to order 676 files. If you need a larger or smaller amount of characters you can specify this as an argument to `aaaa`:

  ```python
  from aaaa import aaaa

  names_short = aaaa(1)
  names_long = aaaa(4)

  print(next(names_short), next(names_long))


  ```

  Beyond four or five characters in length, initializing `aaaa` becomes prohibitively slow. Note that four characters gives you **456976** permutations - so you should never need more than this.




  For my purposes this package is feature complete, but if you find a bug, or have a feature request, open an issue, or create a pull request!




  The project is licensed under the MIT license.


pkgId: df07c1e6d7542d382cf8f38418d81c30dd64373cd9f6c3de0c61027e48b9cdbb
name: python-aaindex
arch: src
version: 1.1.2
epoch: 0
release: 1
url: https://github.com/amckenna41/aaindex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aaindex-1.1.2-1.src.rpm
checksum_type: sha256
summary:
  A lightweight Python software package for accessing the data in the various AAIndex databases, which represent the physiochemical, biochemical and structural properties of amino acids as numerical indices.

description:
    * [Introduction](#introduction)
    * [Requirements](#requirements)
    * [Installation](#installation)
    * [Usage](#usage)
    * [Tests](#tests)
    * [Contact](#contact)
    * [License](#license)
    * [References](#References)


pkgId: 6da3ae75351429960d313e1653cd00dd5957988fe9113047ec771d8e671300e8
name: python-aalpy
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: An active automata learning library
url: https://github.com/DES-Lab/AALpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aalpy-1.4.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <picture style="align: center; padding-bottom: 3mm;">
    <source media="(prefers-color-scheme: dark)" srcset="./docs/logo_dark.png">
    <img width=70% height=70% alt="AALpy Logo" src="./docs/logo_light.png">
  </picture>

  <br/>
  <br/>

  [![Python application](https://github.com/DES-Lab/AALpy/actions/workflows/python-app.yml/badge.svg)](https://github.com/DES-Lab/AALpy/actions/workflows/python-app.yml)
  [![CodeQL](https://github.com/DES-Lab/AALpy/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/DES-Lab/AALpy/actions/workflows/codeql-analysis.yml)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/aalpy)

  [![GitHub issues](https://img.shields.io/github/issues/DES-Lab/AALpy)](https://github.com/DES-Lab/AALpy/issues)
  ![GitHub pull requests](https://img.shields.io/github/issues-pr/des-lab/aalpy)
  [![Python 3.6](https://img.shields.io/badge/python-3.6%2B-blue)](https://www.python.org/downloads/release/python-360/)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/aalpy)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

  </div>
  <hr />

  AALpy is a light-weight automata learning library written in Python.
  You can start learning models of black-box systems with a few lines of code.

  AALpy supports both **active** and **passive** automata learning algorithms that can be used to learn a variety of modeling formalisms, including
  **deterministic**, **non-deterministic**, and **stochastic automata**, as well as **deterministic context-free grammars/pushdown automata**.

  <div align="center">

  | **Automata Type** |                      **Supported Formalisms**                     | **Algorithms**        |                                                       **Features** |
  |-------------------|:-----------------------------------------------------------------:|-----------------------|-------------------------------------------------------------------:|
  | Deterministic     |                 DFAs <br /> Mealy Machines <br /> Moore Machines                 |      L* <br /> KV <br /> RPNI      | Seamless Caching <br /> Counterexample Processing <br /> 13 Equivalence Oracles  |
  | Non-Deterministic |                      ONFSM <br /> Abstracted ONFSM                      |        L*<sub>ONFSM</sub>       |                                 Size Reduction  Trough Abstraction |
  | Stochastic        | Markov Decision Processes <br /> Stochastic Mealy Machines <br /> Markov Chains | L*<sub>MDP</sub> <br /> L*<sub>SMM</sub> <br /> ALERGIA |               Counterexample Processing <br /> Exportable to PRISM format  <br /> Bindings to jALERGIA|
  | Pushdown          |          VPA/SEVPA                                                            | KV<sub>VPA</sub> <br /> PAPNI | Passive learning of VPAs <br /> Exclusive call-return pairs
  </div>



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install the latest release of AALpy:
  ```bash
  pip install aalpy
  ```
  To install current version of the master branch (it might contain bugfixes and added functionalities between releases):
  ```bash
  pip install https://github.com/DES-Lab/AALpy/archive/master.zip
  ```
  The minimum required version of Python is 3.6.
  Ensure that you have [Graphviz](https://graphviz.org/) installed and added to your path if you want to visualize models.

  For manual installation, clone the repo and install `pydot` (the only dependency).



  If you are interested in automata learning or would like to understand the automata learning process in more detail,
  please check out our **Wiki**. On Wiki, you will find more detailed examples on how to use AALpy.
  - <https://github.com/DES-Lab/AALpy/wiki>

  ***[Examples.py](https://github.com/DES-Lab/AALpy/blob/master/Examples.py)*** contains examples covering almost the whole of AALpy's functionality and its a great starting point.



  All active automata learning procedures follow this high-level approach:
  - [Define the input alphabet and system under learning (SUL)](https://github.com/DES-Lab/AALpy/wiki/SUL-Interface,-or-How-to-Learn-Your-Systems)
  - [Choose the equivalence oracle](https://github.com/DES-Lab/AALpy/wiki/Equivalence-Oracles)
  - [Run the learning algorithm](https://github.com/DES-Lab/AALpy/wiki/Setting-Up-Learning)

  Passive learning algorithm simply require you to provide data in the appropriate format (check Wiki and Examples) and run the learning function.


  <details>
    <summary>Code snipped demonstrating some of AALpy's functionalities</summary>

  The following snippet demonstrates a short example in which an automaton is either [loaded](https://github.com/DES-Lab/AALpy/wiki/Loading,Saving,-Syntax-and-Visualization-of-Automata) or [randomly generated](https://github.com/DES-Lab/AALpy/wiki/Generation-of-Random-Automata) and then [learned](https://github.com/DES-Lab/AALpy/wiki/Setting-Up-Learning).
  ```python
  from aalpy.utils import load_automaton_from_file, generate_random_deterministic_automata
  from aalpy.SULs import AutomatonSUL
  from aalpy.oracles import RandomWalkEqOracle
  from aalpy.learning_algs import run_Lstar, run_KV





  random_dfa = generate_random_deterministic_automata(automaton_type='dfa', num_states=8,
                                                      input_alphabet_size=5, output_alphabet_size=2)


  alphabet = random_dfa.get_input_alphabet()




  sul = AutomatonSUL(random_dfa)


  eq_oracle = RandomWalkEqOracle(alphabet, sul, num_steps=5000, reset_prob=0.09)



  learned_dfa = run_KV(alphabet, sul, eq_oracle, automaton_type='dfa')






  learned_dfa.save()



  learned_dfa.visualize()

  print(learned_dfa)
  ```
  </details>

  To make experiments reproducible, define a random seed at the beginning of your program.
  ```Python
  from random import seed
  seed(2) # all experiments will be reproducible
  ```


  AALpy has been used to:
  - [Learn Models of Bluetooth Low-Energy](https://github.com/apferscher/ble-learning)
  - [Find bugs in VIM text editor](https://github.com/DES-Lab/AALpy/discussions/13)
  - [Learn Input-Output Behavior of RNNs](https://github.com/DES-Lab/Extracting-FSM-From-RNNs)
  - [Learn Models of GIT](https://github.com/taburg/git-learning)
  - [Solve RL Problems](https://github.com/DES-Lab/Learning-Environment-Models-with-Continuous-Stochastic-Dynamics)


  If you use AALpy in your research, please cite us with of the following:
  - [Extended version (preferred)](https://www.researchgate.net/publication/359517046_AALpy_an_active_automata_learning_library/citation/download)
  - [Tool paper](https://dblp.org/rec/conf/atva/MuskardinAPPT21.html?view=bibtex)

  If you have research suggestions or you need specific help concerning your research, feel free to start a [discussion](https://github.com/DES-Lab/AALpy/discussions) or contact [edi.muskardin@silicon-austria.com](mailto:edi.muskardin@silicon-austria.com).
  We are happy to help you and consult you in applying automata learning in various domains.


  Pull requests are welcome. For significant changes, please open an issue first to discuss what you would like to change.
  In case of any questions or possible bugs, please open issues.


pkgId: 626de05746441a3400cc587403d3cbf48fdde34b024a0eb43820ff9d23fc34ea
name: python-abstracttree
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Abstract base classes for tree data structures
url: https://github.com/lverweijen/abstracttree
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: vm-2p16g.taishan200-2280-2s48p-256g--a35-0.compass-ci.net
location_href: Packages/python-abstracttree-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This Python package contains a few abstract base classes for tree data structures.
  Trees are very common data structure that represents a hierarchy of common nodes.
  There are many different ways to represent them.
  This package tries to provide a uniform interface, mixin methods and some utility functions without settling on a concrete tree implementation.



  ```python
  from abstracttree import DownTree, to_mermaid

  to_mermaid(DownTree)
  ```

  ```mermaid
  graph TD;
  Tree[Tree];
  MutableTree[MutableTree];
  DownTree[DownTree];
  Tree[Tree];
  MutableTree[MutableTree];
  MutableDownTree[MutableDownTree];
  MutableTree[MutableTree];
  BinaryDownTree[BinaryDownTree];
  BinaryTree[BinaryTree];
  Tree-->MutableTree;
  DownTree-->Tree;
  DownTree-->MutableDownTree;
  MutableDownTree-->MutableTree;
  DownTree-->BinaryDownTree;
  BinaryDownTree-->BinaryTree;
  Tree-->BinaryTree;
  ```

  A `Downtree` needs to have links to its direct children, but doesn't require a link to its parent.
  A `Tree` needs to have links to both its `children` and its `parent`.

  | ABC               | Inherits from             | Abstract Methods                | Mixin Methods                                                                                                                                                           |
  |-------------------|---------------------------|---------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `DownTree`        |                           | `children`                      | `nodes`, `nodes.preorder()`, `nodes.postorder()`, `nodes.levelorder()`, `descendants`, `leaves`, `levels`, `levels.zigzag()`, `is_leaf`, `transform()`,  `nid`, `eqv()` |
  | `Tree`            | `DownTree`                | `parent`                        | `root`, `is_root`, `ancestors`, `path`, `siblings`                                                                                                                      |
  | `MutableDownTree` | `DownTree`                | `add_child()`, `remove_child()` | `add_children()`                                                                                                                                                        |
  | `MutableTree`     | `Tree`, `MutableDownTree` |                                 | `detach()`                                                                                                                                                              |
  | `BinaryDownTree`  | `DownTree`                | `left_child`, `right_child`     | `children`, `nodes.inorder()`, `descendants.inorder()`                                                                                                                  |
  | `BinaryTree`      | `BinaryDownTree`, `Tree`  |                                 |                                                                                                                                                                         |

  In your own code, you can inherit from these trees.
  For example, if your tree only has links to children:

  ```python
  import abstracttree
  from abstracttree import print_tree

  class MyTree(abstracttree.DownTree):
      def __init__(self, value, children=()):
          self.value = value
          self._children = children

      def __str__(self):
          return "MyTree " + str(self.value)

      @property
      def children(self):
          return self._children

  tree = MyTree(1, children=[MyTree(2), MyTree(3)])
  print_tree(tree)





  ```



  In practice, not all existing tree data structures implement one of these abstract classes.
  As a bridge, you can use `AbstractTree.convert` to convert these trees to a `Tree` instance.
  However, whenever possible, it's recommended to inherit from `Tree` directly for minimal overhead.

  Examples:

  ```python

  tree = Tree.convert(int)
  tree = Tree.convert(ast.parse("1 + 1 == 2"))
  tree = Tree.convert(pathlib.Path("abstracttree"))


  tree = Tree.convert(anytree.Node('name'))


  tree = Tree.convert([[1, 2, 3], [4, 5, 6]])
  ```

  Or use `astree` if you need a custom function for `parent` or `children`:

  ```python

  data = {"name": "a",
          "children": [
              {"name": "b", "children": []},
              {"name": "c", "children": []}
  ]}
  astree(data, children=operator.itemgetter["children"])


  astree(widget, children=lambda w: w.children(), parent = lambda w: w.parent())


  astree(tree.root, children=lambda nid: tree.children(nid), parent=lambda nid: tree.parent(nid))


  astree(tree, children=iter, parent=lambda t: t.parent)


  inf_binary = astree(0, children=lambda n: (2*n + 1, 2*n + 2))
  ```



  Pretty printing
  ```python
  tree = astree(seq, children=lambda x: [x[:-2], x[1:]] if x else [])
  print_tree(tree)
  print(to_string(tree))








  ```

  Plotting with matplotlib
  ```python
  import matplotlib.pyplot as plt

  expr = ast.parse("y = x*x + 1")
  plot_tree(expr)
  plt.show()
  ```
  ![images/tree_calc_plot.png](images/tree_calc_plot.png)

  Export to various formats
  ```python
  to_dot(tree)
  to_mermaid(tree)
  to_latex(tree)
  to_reportlab(tree)

  to_image(Path('.'), "filetree.png", how="dot")
  to_image(AbstractTree, "class_hierarchy.svg", how="mermaid")
  to_pillow(tree).show()
  ```



  ```python
  import heapq

  from abstracttree import HeapTree, Route

  tree = HeapTree([5, 4, 3, 2, 1])
  heapq.heapify(tree.heap)
  route = Route(tree.left_child, tree.right_child)

  print(f"{route.lca = }")  # => HeapTree([1, 2, 3, 5, 4], 0)
  print(f"{route.nodes.count() = }")  # => 3
  print(f"{route.edges.count() = }")  # => 2
  ```



  - [anytree](https://github.com/c0fec0de/anytree)
  - [treelib](https://github.com/caesar0301/treelib)
  - [bigtree](https://github.com/kayjan/bigtree)
  - [itertree](https://github.com/BR1py/itertree)
  - [dendropy](https://github.com/jeetsukumaran/DendroPy)
  - [ete](https://github.com/etetoolkit/ete)
  - [littletree](https://github.com/lverweijen/littletree) - also by me



  - [PrettyPrintTree](https://github.com/AharonSambol/PrettyPrintTree) - colored terminal output


pkgId: 709d0253f5e8d896b4154b32527620c912ea2361331205c2d32aa552f9123d7a
name: python-accasim
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: An HPC Workload Management Simulator
url: http://accasim.readthedocs.io/en/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-accasim-1.1.3-1.src.rpm
checksum_type: sha256
description:
  *current version:* |version|
  AccaSim is a Workload management [sim]ulator for [H]PC systems, useful for developing dispatchers and conducting controlled experiments in HPC dispatching research. It is scalable and highly customizable, allowing to carry out large experiments across different workload sources, resource settings, and dispatching methods.
  AccaSim enables users to design novel advanced dispatchers by exploiting information regarding the current system status, which can be extended for including custom behaviors such as power consumption and failures of the resources. The researchers can use AccaSim for instance to mimic any real system by setting up the synthetic resources suitably, develop advanced power-aware, fault-resilient dispatching methods, and test them over a wide range of workloads by generating them synthetically or using real workload traces from HPC users.
  For more information please visit the `webpage of AccaSim <http://accasim.readthedocs.io/en/latest/>`_
  ***************
  What's new?
  ***************
  - 23-06-2018 Major improvements. Additional data is executed during Submission, Dispatching and Completion events (before and after).
  - 15-06-2018 Version 1.0 released.
  - 01-06-2018 New version of the dispatchers. The job requests are verified during the scheduling process.
  - 27-05-2018 New version of the resources and resource manager. All simulation methods were improved. Logger is used instead of printing messages.
  - 21-05-2018 Asyncronous file writing to reduce the IO overhead of the simulations.
  - 06-12-2017 A workload generator is available for generating new workloads from existing workloads.
  - 13-11-2017 Simulating distinct dispatchers under the same system and simulator configuration can be managed under the Experimentation class. It also includes the automatic plot generation.
  - 21-08-2017 Automatic plot generation for comparison of multiple workload schedules and benchmark files: Slowdown, Queue sizes, Load ratio, Efficiency, Scalability, Simulation time, Memory Usage.
  - 19-07-2017 Documentation is moved to `http://accasim.readthedocs.io <http://accasim.readthedocs.io/en/latest/>`_
  - 12-07-2017 First version of the package.


pkgId: 0ece4c006da9de8c0af2ad67d6b812b14e432647396f5f6d792c084cca607c77
name: python-acceptlang
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A package for parsing Accept-Language tag received from (untrusted) client context.
url: https://github.com/piotrszyma/acceptlang
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-acceptlang-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This package can be used in the server environment to parse the Accept-Language
  header.

  Test cases and code copied from Django source code enhanced with typing.

  Purpose of this code is to be able to use a battle-tested Accept-Language
  parsing logic in Python code without need to install Django package.



  You can install the package via pip:

  ```sh
  pip install acceptlang
  ```



  ```python
  from acceptlang import parse_accept_lang_header

  result = parse_accept_lang_header("en-us,en;q=0.5,de;q=0.3")
  assert result == (('en-us', 1.0), ('en',0.5), ('de',0.3))

  result = parse_accept_lang_header("en-us,*;q=0.5")
  assert result == (('en-us', 1.0), ('*',0.5))
  ```

  Check [tests](tests/test_parse.py) for more examples.



  ```sh
  python3 -m venv venv
  . venv/bin/activate
  python3 -m pip install -r requirements.dev.txt
  ```



  ```sh
  python3 -m build --wheel
  twine check dist/**
  twine upload dist/
  ```


pkgId: 1c3b54d8ee47247007bc35dbaab3f9cb52602d6487146b446d764dca509c8afb
name: python-acpipe-acjson
arch: src
version: 0.1.17
epoch: 0
release: 1
url: https://gitlab.com/biotransistor/acpipe_acjson
rpm_license: GPL>=3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-acpipe-acjson-0.1.17-1.src.rpm
checksum_type: sha256
summary:
  acpipe_acjson is the python3 acjson base library. acjson - assay coordinate json - is a file format developed to log complicated biological wetlab experiment layouts.

description:
  This is a python3 library to produce and process acjson objects.

  Acjson (assay coordinate java script object notation) is
  in the big picture a json syntax (http://json.org/) compatible file format,
  that was developed to capture the most essential experimental annotations
  of a biological wetlab experiment,
  how ever simple or complicated the layout may be.

  In the guts of this file format is each experimental condition described as a single coordinate.

  Each coordinate is an adaptation of the input-processing-output (IPO) model from software engineering,
  which is used to describe the structure of an information processing program.
  In the biological experiment use-case, these are represented by (SPE) sample, perturbation, and assay endpoints,
  which are represented as three axes.

  Each of this axis can hold as many sample or reagent records as needed to describe the experimental condition.

  This library can produce and process such acjson objects.




  How to install acpipe_acjson?
  ```bash
  pip3 install acpipe_acjson
  ```

  How to load the acpipe_acjson library?
  ```python
  import acpipe_acjson.acjson as ac
  ```

  Howto get reference information about the implemented constants and functions?
  ```python
  import acpipe_acjson.acjson as ac


  ac.ts_ABC
  ac.ts_ACAXIS
  ac.ts_NOTCOOR
  ac.ts_COORSYS
  ac.d_WELL
  ac.d_RECORD
  ac.d_RECORDLONG


  ac.d_SET
  ac.d_EXTERNALID
  ac.d_SAMPLE
  ac.d_MICROSCOPE
  ac.d_PRIMANTIBODY
  ac.d_SECANTIBODY


  ac.leaf
  ac.es_DATAFRAMELEAF


  ac.dii_96A1
  ac.dii_96A2
  ac.dii_96B1
  ac.dii_96B2


  help(ac.retype)
  help(ac.escoor)
  help(ac.icoormax)
  help(ac.ispotmax)
  help(ac.ispot)
  help(ac.xy2icoor)
  help(ac.acrelabel)
  help(ac.acbuild)
  help(ac.acfuseaxisrecord)
  help(ac.acfusewellrecord)
  help(ac.acfuserepeat0011)
  help(ac.acfuserepeat0101)
  help(ac.acfuseobject)
  help(ac.acfuse4to1)
  help(ac.count_record)
  help(ac.record_in_acjson)
  help(ac.list_uniq_record)
  help(ac.max_record)
  help(ac.pop_record)
  help(ac.pop_ac)
  help(ac.xray)
  help(ac.acjson2layouttsv)
  help(ac.acjson2dataframetsv)
  ```


pkgId: ef706a5fd341a9b1fa8e336751396215817a194ad101de1f741acee19661deb4
name: python-acsylla
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A high performance asynchronous Cassandra and ScyllaDB client
url: http://github.com/acsylla/acsylla
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-acsylla-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/acsylla/acsylla/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/acsylla/acsylla/actions/workflows/ci.yml)
  [![CI](https://github.com/acsylla/acsylla/actions/workflows/release.yml/badge.svg?branch=v0.1.7a0)](https://github.com/acsylla/acsylla/actions/workflows/release.yml)
  [![PyPI](https://img.shields.io/pypi/v/acsylla.svg)](https://pypi.org/project/acsylla/)
  [![Number of PyPI downloads](https://img.shields.io/pypi/dm/acsylla.svg)](https://pypi.org/project/acsylla/)
  [![Documentation Status](https://readthedocs.org/projects/acsylla/badge/?version=latest)](https://acsylla.readthedocs.io/en/latest/)


  A composition of ***async*** + ***cassandra*** + ***scylla*** words.



  Under the hood **_acsylla_** has modern, feature-rich and shard-aware [C/C++ client](https://github.com/scylladb/cpp-driver) library for [Cassandra](https://cassandra.apache.org) and [ScyllaDB](https://www.scylladb.com).


    * [Features](#features)
    * [Compatibility](#compatibility)
    * [Install](#install)
    * [Cluster](#cluster)
      * [Configuration options](#configuration-options)
      * [Configuration methods](#configuration-methods)
    * [Session](#session)
    * [Statement](#statement)
    * [PreparedStatement](#preparedstatement)
    * [Batch](#batch)
    * [Result](#result)
    * [Row](#row)
    * [Logger](#logger)
    * [Examples](#examples)
      * [Basic usage](#basic-usage)
      * [Binding Parameters](#binding-parameters)
        * [Non Prepared Statement](#non-prepared-statement)
        * [Prepared Statement](#prepared-statement)
      * [Use prepared statement and paging](#use-prepared-statement-and-paging)
      * [Configure Shard-Awareness connection](#configure-shard-awareness-connection-to-scylladb-cluster)
      * [SSL Example](#ssl-example)
      * [Retrieving metadata](#retrieving-metadata)
      * [Configure logging](#configure-logging)
        * [Set log level](#set-log-level)
        * [Set callback for capture log messages](#set-callback-for-capture-log-messages)
      * [Execution profiles](#execution-profiles)
      * [Tracing](#tracing)
      * [Host State Changes](#host-state-changes)
    * [Developing](#developing)




  * Shard-Awareness
  * Asynchronous API
  * Simple, Prepared, and Batch statements
  * Asynchronous I/O, parallel execution, and request pipelining
  * Connection pooling
  * Automatic node discovery
  * Automatic reconnection
  * Configurable load balancing
  * Works with any cluster size
  * Authentication
  * SSL
  * Latency-aware routing
  * Performance metrics
  * Tuples and UDTs
  * Nested collections
  * Retry policies
  * Client-side timestamps
  * Data types
  * Idle connection heartbeats
  * Support for materialized view and secondary index metadata
  * Support for clustering key order, `frozen<>` and Cassandra version metadata
  * Whitelist/blacklist DC, and whitelist/blacklist hosts load balancing policies
  * Custom authenticators
  * Reverse DNS with SSL peer identity verification support
  * Randomized contact points
  * Speculative execution



  This driver works exclusively with the Cassandra Query Language v3 (CQL3) and
  Cassandra's native protocol. The current version works with:

  * Scylla and Scylla Enterprise
  * Apache Cassandra® versions 2.1, 2.2 and 3.0+
  * Python 3.7, 3.8, 3.9, 3.10 and 3.11 for Linux and MacOS



  There is an Beta realease compabitble with Python 3.7, 3.8, 3.9, 3.10 and 3.11 for Linux and MacOS environments uploaded as a Pypi package. Use the following
  command for installing it:

  ```bash
  pip install acsylla
  ```


  You can build your own package for any supported python version for ***x86_64*** and ***aarch64*** Linux.

  Example for build wheel for Python 3.12 ***x86_64*** from master branch
  ```bash
  git clone https://github.com/acsylla/acsylla.git
  cd acsylla
  docker run -v `pwd`:/io -e PYTHON_VERSION=3.12  quay.io/pypa/manylinux_2_28_x86_64  /io/bin/build_manylinux_2_28_wheel.sh
  ```

  Example for build wheel for Python 3.12 ***aarch64*** from master branch
  ```bash
  git clone https://github.com/acsylla/acsylla.git
  cd acsylla
  docker run --platform linux/arm64 -v `pwd`:/io -e PYTHON_VERSION=3.12  quay.io/pypa/manylinux_2_28_aarch64  /io/bin/build_manylinux_2_28_wheel.sh
  ```



  The `Cluster` object describes a Cassandra/ScyllaDB cluster’s configuration.
  The ***default cluster object is good for most clusters*** and only requires a single
  or multiple list of contact points in order to establish a session connection.
  ***For example:***
  `cluster = acsylla.create_cluster('127.0.0.1, 127.0.0.2')`

  Once a session is connected using a cluster object its configuration is constant.

  Modifying the cluster object configuration once a session is established does not alter the session’s configuration.



  List of named arguments to configure cluster with  `acsylla.create_cluster` helper.

  - ***contact_points:*** Sets contact points. This MUST be set. White space is striped from the contact points.
      *Examples:* “127.0.0.1”,  “127.0.0.1,127.0.0.2”, “server1.domain.com”

  - ***port:*** Sets the port.
      *Default:* 9042

  - ***local_address:*** Sets the local address to bind when connecting to the
      cluster, if desired. IP address to bind, or empty string for no
      binding. Only numeric addresses are supported; no resolution is done.

  - ***local_port_range_min:*** Sets the range of outgoing port numbers (ephemeral
      ports) to be used when establishing the shard-aware connections. This
      is applicable when the routing of connection to shard is based on the
      client-side port number.
      When application connects to multiple CassCluster-s it is advised
      to assign mutually non-overlapping port intervals to each. It is assumed
      that the supplied range is allowed by the OS (e.g. it fits inside
      /proc/sys/net/ipv4/ip_local_port_range on *nix systems)
      *Default:* `49152`

  - ***local_port_range_max:*** See `local_port_range_min`
      *Default:* `65535`

  - ***username:*** Set username for plain text authentication.

  - ***password:*** Set password for plain text authentication.

  - ***connect_timeout:*** Sets the timeout for connecting to a node.
      *Default:* `5` seconds

  - ***request_timeout:*** Sets the timeout for waiting for a response from a node.
      Use 0 for no timeout.
      *Default:* `12` seconds

  - ***resolve_timeout:*** Sets the timeout for waiting for DNS name resolution.
      *Default:* `2` seconds

  - ***log_level:*** Sets the log level.
      Available levels:
    - `disabled`
    - `critical`
    - `error`
    - `warn`
    - `info`
    - `debug`
    - `trace`

    *Default:* `warn`

  - ***logging_callback:*** Sets a callback function to catch log messages.
      *Default:* An internal logger with "acsylla" name.
      `logging.getLogger('acsylla')`

  - ***ssl_enable:*** Enable SSL connection
      *Default:* `False`

  - ***ssl_cert:*** Set client-side certificate chain. This is used to authenticate
      the client on the server-side. This should contain the entire
      Certificate chain starting with the certificate itself

  - ***ssl_private_key:*** Set client-side private key. This is used to authenticate
      the client on the server-side.

  - ***ssl_private_key_password:*** Password for `ssl_private_key`

  - ***ssl_trusted_cert:*** Adds a trusted certificate. This is used to verify the
      peer’s certificate.

  - ***ssl_verify_flags:*** Sets verification performed on the peer’s certificate.
      - `NONE` No verification is performed
      - `PEER_CERT` Certificate is present and valid
      - `PEER_IDENTITY` IP address matches the certificate’s common name or one
            of its subject alternative names. This implies the certificate is
            also present.
      - `PEER_IDENTITY_DNS` Hostname matches the certificate’s common name or
            one of its subject alternative names. This implies the certificate
            is also present.
        *Default:* `PEER_CERT`

  - ***protocol_version:*** Sets the protocol version. The driver will automatically
      downgrade to the lowest supported protocol version.
      *Default:* `acsylla.ProtocolVersion.V4` or `acsylla.ProtocolVersion.DSEV1` when
      using the DSE driver with DataStax Enterprise.

  - ***use_beta_protocol_version:*** Use the newest beta protocol version. This
      currently enables the use of protocol version `cyacsylla.ProtocolVersion.V5`
      or `cyacsylla.ProtocolVersion.DSEV2` when using the DSE driver with
      DataStax Enterprise.
      *Default:* `False`

  - ***consistency:*** Sets default consistency level of statement. `acsylla.Consistency`
      *Default:* `LOCAL_ONE`

  - ***serial_consistency:*** Sets default serial consistency level of statement. `acsylla.Consistency`
      *Default:* `ANY`

  - ***queue_size_io:*** Sets the size of the fixed size queue that stores pending
      requests.
      *Default:* `8192`

  - ***num_threads_io:*** Sets the number of IO threads. This is the number of threads that
      will handle query requests.
      *Default:* `1`

  - ***core_connections_per_host:*** Sets the number of connections made to each
      server in each IO thread.
      *Default:* `1`

  - ***constant_reconnect_delay_ms:*** Configures the cluster to use a reconnection
      policy that waits a constant time between each reconnection attempt.
      Time in milliseconds to delay attempting a reconnection; 0 to perform
      a reconnection immediately.
      *Default:* Not set

  - ***exponential_reconnect_base_delay_ms:*** The base delay (in milliseconds) to
      use for scheduling reconnection attempts.
      Configures the cluster to use a reconnection policy that waits
      exponentially longer between each reconnection attempt; however will
      maintain a constant delay once the maximum delay is reached.
      *Note:* A random amount of jitter (+/- 15%) will be added to the pure
      exponential delay value. This helps to prevent situations where
      multiple connections are in the reconnection process at exactly the
      same time. The jitter will never cause the delay to be less than the
      base delay, or more than the max delay.
      *Default:* `2000`

  - ***exponential_reconnect_max_delay_ms:*** The maximum delay to wait between two
      reconnection attempts. See `exponential_reconnect_max_delay_ms`
      *Default:* `60000`

  - ***coalesce_delay_us:*** Sets the amount of time, in microseconds, to wait for
      new requests to coalesce into a single system call. This should be set
      to a value around the latency SLA of your application’s requests while
      also considering the request’s roundtrip time. Larger values should be
      used for throughput bound workloads and lower values should be used for
      latency bound workloads.
      *Default:* `200` us

  - ***new_request_ratio:*** Sets the ratio of time spent processing new requests
      versus handling the I/O and processing of outstanding requests. The
      range of this setting is 1 to 100, where larger values allocate more
      time to processing new requests and smaller values allocate more time
      to processing outstanding requests.
      *Default:* `50`

  - ***max_schema_wait_time_ms:*** Sets the maximum time to wait for schema
      agreement after a schema change is made (e.g. creating, altering,
      dropping a table/keyspace/view/index etc).
      *Default:* `10000` milliseconds

  - ***tracing_max_wait_time_ms:*** Sets the maximum time to wait for tracing data to become available.
      *Default:* `15` milliseconds

  - ***tracing_retry_wait_time_ms:*** Sets the amount of time to wait between attempts to check to see if tracing is available.
      *Default:*  `3` milliseconds

  - ***tracing_consistency:*** Sets the consistency level to use for checking to see if tracing data is available.
      *Default:* `ONE`

  - ***load_balance_round_robin:*** Configures the cluster to use round-robin load
      balancing. The driver discovers all nodes in a cluster and cycles
      through them per request. All are considered local.

  - ***load_balance_dc_aware:*** The primary data center to try first.
      Configures the cluster to use DC-aware load balancing. For each query,
      all live nodes in a primary ‘local’ DC are tried first, followed by any
      node from other DCs.
      *Note:* This is the default, and does not need to be called unless
      switching an existing from another policy or changing settings. Without
      further configuration, a default local_dc is chosen from the first
      connected contact point, and no remote hosts are considered in query
      plans. If relying on this mechanism, be sure to use only contact points
      from the local DC.

  - ***load_balance_rack_aware_dc:*** Configures the cluster to use Rack-aware load
      balancing.
      For each query, all live nodes in a primary 'local' rack are tried first,
      followed by nodes from local DC and then nodes from other DCs.
      With empty local_rack and local_dc,  default local_dc and local_rack
      is chosen from the first connected contact point,
      and no remote hosts are considered in query plans.
      If relying on this mechanism, be sure to use only contact
      points from the local rack.

  - ***load_balance_rack_aware_rack:*** Configures the cluster to use Rack-aware load
      balancing.
      For each query, all live nodes in a primary 'local' rack are tried first,
      followed by nodes from local DC and then nodes from other DCs.
      With empty local_rack and local_dc,  default local_dc and local_rack
      is chosen from the first connected contact point,
      and no remote hosts are considered in query plans.
      If relying on this mechanism, be sure to use only contact
      points from the local rack.

  - ***token_aware_routing:*** Configures the cluster to use token-aware request
      routing or not. This routing policy composes the base routing policy,
      routing requests first to replicas on nodes considered ‘local’ by the
      base load balancing policy.
      *Important:* Token-aware routing depends on keyspace metadata. For this
      reason enabling token-aware routing will also enable retrieving and
      updating keyspace schema metadata.
      *Default:* `True` (enabled).

  - ***token_aware_routing_shuffle_replicas:*** Configures token-aware routing to
      randomly shuffle replicas. This can reduce the effectiveness of
      server-side caching, but it can better distribute load over replicas
      for a given partition key.
      *Note:* Token-aware routing `token_aware_routing` must be enabled for the
      setting to be  applicable.
      *Default:* `True` (enabled).

  - ***latency_aware_routing:*** Configures the cluster to use latency-aware request
      routing or not. This routing policy is a top-level routing policy. It
      uses the base routing policy to determine locality (dc-aware) and/or
      placement (token-aware) before considering the latency.
      *Default:* `False` (disabled).

  - ***latency_aware_routing_settings:*** Configures the settings for latency-aware
      request routing. Instance of `acsylla.LatencyAwareRoutingSettings`
      *Default:*
      - `exclusion_threshold` ***2.0*** *Controls how much worse the latency
                                        be compared to the average latency of
                                        the best performing node before it
                                        penalized.*
      - `scale_ms` ***100 milliseconds*** *Controls the weight given to older
                                        latencies when calculating the average
                                        latency of a node. A bigger scale will
                                        give more weight to older latency
                                        measurements.*
      - `retry_period_ms` ***10,000 milliseconds*** *The amount of time a node is
                                        penalized by the policy before being
                                        given a second chance when the current
                                        average latency exceeds the calculated
                                        threshold (exclusion_threshold *
                                        best_average_latency).*
      - `update_rate_ms` ***100 milliseconds*** *The rate at which the best
                                        average latency is recomputed.*
      - `min_measured` ***50*** *The minimum number of measurements per-host
                                        required to be considered by the policy*

  - ***whitelist_hosts:*** Sets whitelist hosts. The first call sets the whitelist
      hosts and any subsequent calls appends additional hosts. Passing an
      empty string will clear and disable the whitelist. White space is
      striped from the hosts.
      This policy filters requests to all other policies, only allowing
      requests to the hosts contained in the whitelist. Any host not in the
      whitelist will be ignored and a connection will not be established.
      This policy is useful for ensuring that the driver will only connect to
      a predefined set of hosts.
      *Examples*: “127.0.0.1”, “127.0.0.1,127.0.0.2”

  - ***blacklist_hosts:*** Sets blacklist hosts. The first call sets the blacklist
      hosts and any subsequent calls appends additional hosts. Passing an
      empty string will clear and disable the blacklist. White space is
      striped from the hosts.
      This policy filters requests to all other policies, only allowing
      requests to the hosts not contained in the blacklist. Any host in the
      blacklist will be ignored and a connection will not be established.
      This policy is useful for ensuring that the driver will not connect to
      a predefined set of hosts.
      *Examples*: “127.0.0.1”, “127.0.0.1,127.0.0.2”

  - ***whitelist_dc:*** Same as `whitelist_hosts`, but whitelist all hosts of a dc
      *Examples*: “dc1”, “dc1,dc2”

  - ***blacklist_dc:*** Same as `blacklist_hosts`, but blacklist all hosts of a dc
      *Examples*: “dc1”, “dc1,dc2”

  - ***tcp_nodelay:*** Enable/Disable Nagle’s algorithm on connections.
      *Default:* True

  - ***tcp_keepalive_sec:*** Set keep-alive delay in seconds.
      *Default:* disabled

  - ***timestamp_gen:*** "server_side" or "monotonic" Sets the timestamp generator
      used to assign timestamps to all requests unless overridden by setting
      the timestamp on a statement or a batch.
      *Default:* Monotonically increasing, client-side timestamp generator.

  - ***heartbeat_interval_sec:*** Sets the amount of time between heartbeat messages
      and controls the amount of time the connection must be idle before
      sending heartbeat messages. This is useful for preventing intermediate
      network devices from dropping connections.
      *Default:* 30 seconds

  - ***idle_timeout_sec:*** Sets the amount of time a connection is allowed to be
      without a successful heartbeat response before being terminated and
      scheduled for reconnection.
      *Default:* 60 seconds

  - ***retry_policy:*** May be set to `default` or `fallthrough` Sets the retry policy used for
      all requests unless overridden by setting a retry policy on a statement
      or a batch.
      - `default` This policy retries queries in the following cases:
        - On a read timeout, if enough replicas replied but data was not received.
        - On a write timeout, if a timeout occurs while writing the distributed batch log
        - On unavailable, it will move to the next host
        - In all other cases the error will be returned. This policy always uses the query’s original consistency level.
      - `fallthrough` This policy never retries or ignores a server-side
          failure. The error is always returned.

      *Default:* `default` This policy will retry on a read timeout if there
      was enough replicas, but no data present, on a write timeout if a
      logged batch request failed to write the batch log, and on a
      unavailable error it retries using a new host. In all other cases the
      default policy will return an error.

  - ***retry_policy_logging:*** This policy logs the retry decision of its child
      policy. Logging is done using INFO level.
      *Default:* False

  - ***use_schema:*** Enable/Disable retrieving and updating schema metadata. If
      disabled this is allows the driver to skip over retrieving and updating
      schema metadata and `session.get_metadata()` will
      always return an empty object. This can be useful for reducing the
      startup overhead of short-lived sessions.
      *Default:* True (enabled)

  - ***hostname_resolution:*** Enable retrieving hostnames for IP addresses
      using reverse IP lookup. This is useful for authentication (Kerberos)
      or encryption (SSL) services that require a valid hostname for
      verification.
      *Default:* False (disabled)

  - ***randomized_contact_points:*** Enable/Disable the randomization of the contact
      points list.
      *Important:* This setting should only be disabled for debugging or tests.
      *Default:* True (enabled)

  - ***speculative_execution_policy:*** Enable constant speculative executions with
      the supplied settings `acsylla.SpeculativeExecutionPolicy`.

  - ***max_reusable_write_objects:*** Sets the maximum number of “pending write”
      objects that will be saved for re-use for marshalling new requests.
      These objects may hold on to a significant amount of memory and
      reducing the number of these objects may reduce memory usage of the
      application.
         The cost of reducing the value of this setting is potentially slower
      marshalling of requests prior to sending.
      *Default:* Max unsigned integer value

  - ***prepare_on_all_hosts:*** Prepare statements on all available hosts.
      *Default:* True

  - ***no_compact:*** Enable the NO_COMPACT startup option. This can help facilitate
      uninterrupted cluster upgrades where tables using COMPACT_STORAGE will
      operate in “compatibility mode” for BATCH, DELETE, SELECT, and UPDATE
      CQL operations.
      *Default:* False

  - ***host_listener_callback:*** Sets a callback for handling host state changes in
      the cluster.
      Note: The callback is invoked only when state changes in the cluster
      are applicable to the configured load balancing policy(s).

  - ***application_name:*** Set the application name. This is optional; however it
      provides the server with the application name that can aid in debugging
      issues with larger clusters where there are a lot of client (or
      application) connections.

  - ***application_version:*** Set the application version. This is optional;
      however it provides the server with the application version that can
      aid in debugging issues with large clusters where there are a lot of
      client (or application) connections that may have different versions
      in use.

  - ***client_id:*** Set the client id. This is optional; however it provides the
      server with the client ID that can aid in debugging issues with large
      clusters where there are a lot of client connections.
      *Default:* UUID v4 generated

  - ***monitor_reporting_interval_sec:*** Sets the amount of time between monitor
      reporting event messages.
      *Default:* 300 seconds.

  - ***cloud_secure_connection_bundle:*** Absolute path to DBaaS credentials file.
      Sets the secure connection bundle path for processing DBaaS credentials.
      This will pre-configure a cluster using the credentials format provided
      by the DBaaS cloud provider.
      *Note:* `contact_points` and `ssl_enable` should not used in conjunction
      with `cloud_secure_connection_bundle`.

      ***Example:*** "/path/to/secure-connect-database_name.zip"
      *Default:* None

  - ***dse_gssapi_authenticator:*** Enables GSSAPI authentication for DSE clusters
      secured with the DseAuthenticator.
      Instance of `acsylla.DseGssapiAuthenticator`

  - ***dse_gssapi_authenticator_proxy:*** Enables GSSAPI authentication with proxy
      authorization for DSE clusters secured with the DseAuthenticator.
      Instance of `acsylla.DseGssapiAuthenticatorProxy`

  - ***dse_plaintext_authenticator:*** Enables plaintext authentication for DSE
      clusters secured with the DseAuthenticator.
      Instance of `acsylla.DsePlaintextAuthenticator`

  - ***dse_plaintext_authenticator_proxy:*** Enables plaintext authentication with
      proxy authorization for DSE clusters secured with the DseAuthenticator.
      Instance of `acsylla.DsePlaintextAuthenticatorProxy`



  For full list of methods to configure `Cluster` see [base.py](./acsylla/base.py)



  A session object is used to execute queries and maintains cluster state through
  the control connection. The control connection is used to auto-discover nodes
  and monitor cluster changes (topology and schema). Each session also maintains
  multiple pools of connections to cluster nodes which are used to query the cluster.

  ```python
  import acsylla

  cluster = acsylla.create_cluster(['localhost'])
  session = await cluster.create_session(keyspace="acsylla")
  ```



  - ***async def close(self):***
   Closes the session instance, outputs a close future which can be used to
      determine when the session has been terminated. This allows in-flight
      requests to finish.

  - ***async def set_keyspace(self, keyspace: str) -> "Result":***
   Sets the keyspace for session

  - ***def get_client_id(self) -> str:***
   Get the client id.

  - ***def get_metadata(self):***
   Returns `Metadata` instance class for retrieving metadata from cluster.

  - ***async def create_prepared(self, statement: str, timeout: Optional[float] = None) -> PreparedStatement:***
   Create a prepared statement.
   By providing a `timeout` all requests built by the prepared statement will use it, otherwise timeout provided during the `Cluster` instantantation will be used. Value expected is seconds.

  - ***async def execute(self, statement: "Statement") -> Result***
   Executes an statement and returns the `Result` instance.

  - ***async def execute_batch(self, batch: Batch) -> Result:***
   Executes a batch of statements.

  - ***def metrics(self) -> SessionMetrics:***
   Returns the metrics related to the session.

  - ***def speculative_execution_metrics(self) -> SpeculativeExecutionMetrics:***
   Returns speculative execution performance metrics gathered by the driver.



  A statement object is an executable query. It represents either a regular
  (adhoc) statement or a prepared statement. It maintains the queries’ parameter
  values along with query options (consistency level, paging state, etc.)



  - ***def add_key_index(self, index: int) -> None:***
   Adds a key index specifier to this a statement. When using
      token-aware routing, this can be used to tell the driver which
      parameters within a non-prepared, parameterized statement are part of
      the partition key.
   Use consecutive calls for composite partition keys.
   This is not necessary for prepared statements, as the key parameters
      are determined in the metadata processed in the prepare phase.

  - ***def reset_parameters(self, count: int) -> None:***
   Clear and/or resize the statement’s parameters.

  - ***def bind(self, index: int, value: SupportedType) -> None:***
  Binds the value to a specific index parameter.
  If an invalid type is used for a prepared statement this will raise
      immediately an error. If a none prepared exception is used error will
      be raised later during the execution statement.
  If an invalid index is used this will raise immediately an error

  - ***def bind_by_name(self, name: str, value: SupportedType) -> None:***
  Binds the the value to a specific parameter by name.
  If an invalid type is used for this will raise immediately an error. If an
      invalid name is used this will raise immediately an error

  - ***def bind_list(self, values: Sequence[SupportedType]) -> None:***
  Binds the values into all parameters from left to right.
  For types supported and errors that this function might raise take
      a look at the `Statement.bind` function.

  - ***def bind_dict(self, values: Mapping[str, SupportedType]) -> None:***
  Binds the values into all parameter names. Names are the keys
      of the mapping provided.
  For types supported and errors that this function might raise take
      look at the `Statement.bind_dict` function.
  Note: This method are only allowed for statements created using
      prepared statements

  - ***def set_page_size(self, page_size: int) -> None:***
   Sets the statement's page size.

  - ***def set_page_state(self, page_state: bytes) -> None:***
   Sets the statement's paging state. This can be used to get the next
      page of data in a multi-page query.
   *Warning:* The paging state should not be exposed to or come from
      untrusted environments. The paging state could be spoofed and potentially
      used to gain access to other data.


  - ***def set_timeout(self, timeout: float) -> None:***
   Sets the statement's timeout in seconds for waiting for a response from a node.
   *Default:* Disabled (use the cluster-level request timeout)


  - ***def set_consistency(self, timeout: float) -> None:***
   Sets the statement’s consistency level.
   *Default:* LOCAL_ONE

  - ***def set_serial_consistency(self, timeout: float) -> None:***
   Sets the statement’s serial consistency level.
   *Default:* Not set

  - ***def set_timestamp(self, timestamp: int):***
   Sets the statement’s timestamp.

  - ***def set_is_idempotent(self, is_idempotent: bool):***
   Sets whether the statement is idempotent. Idempotent statements are
      able to be automatically retried after timeouts/errors and can be
      speculatively executed.

  - ***def set_retry_policy(self, retry_policy: str, retry_policy_logging: bool = False):***
   Sets the statement’s retry policy.
   May be set to `default` or `fallthrough`
      - `default` This policy retries queries in the following cases:
        - On a read timeout, if enough replicas replied but data was not received.
        - On a write timeout, if a timeout occurs while writing the distributed batch log
        - On unavailable, it will move to the next host
        - In all other cases the error will be returned. This policy always uses the query’s original consistency level.
      - `fallthrough` This policy never retries or ignores a server-side
          failure. The error is always returned.
      *Default:* `default` This policy will retry on a read timeout if there
      was enough replicas, but no data present, on a write timeout if a
      logged batch request failed to write the batch log, and on a
      unavailable error it retries using a new host. In all other cases the
      default policy will return an error.
      - `retry_policy_logging` If set to `True`, this policy logs the retry decision of its child
          policy. Logging is done using `INFO` level. *Default:* `False`

  - ***def set_tracing(self, enabled: bool = None):***
   Sets whether the statement should use tracing.

  - ***def set_host(self, host: str, port: int = 9042):***
   Sets a specific host that should run the query.
   In general, this should not be used, but it can be useful in the
      following situations:
   To query node-local tables such as system and virtual tables.
   To apply a sequence of schema changes where it makes sense for all
      the changes to be applied on a single node.

  - ***def set_execution_profile(self, name: str) -> None:***
   Sets the execution profile to execute the statement with.
      Note: Empty string will clear execution profile from statement

  - ***def set_execute_as(self, name: str) -> None:***
   Sets the name of the user to execute the statement as.




  A statement that has been prepared cluster-side (It has been pre-parsed and cached).



  Use the `session.create_prepared()` coroutine for creating a new instance of `PreparedStatement`.
  ```python
  prepared = await session.create_prepared("SELECT id, value FROM test")
  statement = prepared.bind(page_size=10)
  ```
  - ***def bind(self, page_size: Optional[int] = None, page_state: Optional[bytes] = None, execution_profile: Optional[str] = None,) -> Statement:***
   Returns a new `Statement` using the prepared.

  - ***def set_execution_profile(self, statement: Statement, name: str) -> None:***
   Sets the execution profile to execute the statement with.
   ***Note:*** Empty string will clear execution profile from statement


  A group of statements that are executed as a single batch.


  Use the `acsylla.create_batch_logged()`, `acsylla.create_batch_unlogged()` and
  `acsylla.create_batch_counter()` factories for creating a new instance.

  - ***def set_consistency(self, consistency: int):***
   Sets the batch’s consistency level

  - ***def set_serial_consistency(self, consistency: int):***
   Sets the batch’s serial consistency level.

  - ***def set_timestamp(self, timestamp: int):***
   Sets the batch’s timestamp.

  - ***def set_request_timeout(self, timeout_ms: int):***
   Sets the batch’s timeout for waiting for a response from a node.
   ***Default:*** Disabled (use the cluster-level request timeout)

  - ***def set_is_idempotent(self, is_idempotent):***
   Sets whether the statements in a batch are idempotent. Idempotent
      batches are able to be automatically retried after timeouts/errors and
      can be speculatively executed.

  - ***def set_retry_policy(self, retry_policy: str, retry_policy_logging: bool = False):***
   Sets the batch’s retry policy.
   May be set to `default` or `fallthrough`
      - `default` This policy retries queries in the following cases:
        - On a read timeout, if enough replicas replied but data was not received.
        - On a write timeout, if a timeout occurs while writing the distributed batch log
        - On unavailable, it will move to the next host
        - In all other cases the error will be returned. This policy always uses the query’s original consistency level.
      - `fallthrough` This policy never retries or ignores a server-side
          failure. The error is always returned.
      *Default:* `default` This policy will retry on a read timeout if there
      was enough replicas, but no data present, on a write timeout if a
      logged batch request failed to write the batch log, and on a
      unavailable error it retries using a new host. In all other cases the
      default policy will return an error.
      - `retry_policy_logging` If set to `True`, this policy logs the retry decision of its child
          policy. Logging is done using `INFO` level. *Default:* `False`

  - ***def set_tracing(self, enabled: bool):***
   Sets whether the batch should use tracing.

  - ***def add_statement(self, statement: Statement) -> None:***
   Adds a new statement to the batch.

  - ***def set_execution_profile(self, name: str) -> None:***
   Sets the execution profile to execute the statement with.
   *Note:* Empty string will clear execution profile from statement


  The result of a query.


  Provides a result instance class. Use the `session.execute()` coroutine for
  getting the result  from a query

  - ***def count(self) -> int:***
   Returns the total rows of the result

  - ***def column_count(self) -> int:***
   Returns the total columns returned

  - ***def columns_names(self):***
   Returns the columns names

  - ***def first(self) -> Optional["Row"]:***
   Return the first result, if there is no row returns None.

  - ***def all(self) -> Iterable["Row"]:***
   Return the all rows using of a result, using an iterator.
   If there is no rows iterator returns no rows.

  - ***def has_more_pages(self) -> bool:***
   Returns true if there is still pages to be fetched

  - ***def page_state(self) -> bytes:***
   Returns a token with the page state for continuing fetching
      new results.
   Before calling this method you must first checks if there are more
      results using the `has_more_pages` function, and if there are use the
      token returned by this function as an argument of the factories for creating
      an statement for returning the next page.


  A collection of column values.

  Provides access to a row of a `Result`.
  ```python
  result = await session.execute(statement)
  for row in result:
      print(row.as_dict())
  ```

  - ***def as_dict(self) -> dict:***
   Returns the row as dict.

  - ***def as_list(self) -> list:***
   Returns the row as list.

  - ***def as_tuple(self) -> tuple:***
   Returns the row as tuple.

  - ***def as_named_tuple(self) -> tuple:***
   Returns the row as named tuple.

  - ***def column_count(self) -> int:***
   Returns column count.

  - ***def column_value(self, name: str) -> SupportedType:***
   Returns the row column value called by `name`.
   Raises a `CassException` derived exception if the column can not be found
   Type is inferred by using the Cassandra driver
      and converted, if supported, to a Python type or one
      of the extended types provided by Acsylla.

  - ***def column_value_by_index(self, index):***
   Returns the column value by `column index`.
      Raises an exception if the column can not be found


  The driver’s logging system.


  Use the `acsylla.get_logger()` for acces to `Logger` instance.

  ```python
  logger = acsylla.get_logger()
  ```

  - ***def set_log_level(self, level: str) -> None:***
   Sets the log level.
   Available levels: `disabled`, `critical`, `error`, `warn`, `info`, `debug`, `trace`

  - ***set_logging_callback(self, callback: Callable) -> None:***
   Sets a callback function to catch log messages.
   *Default:* An internal logger with "acsylla" name.

  - ***def get_logger(self) -> None:***
   Returns python logger.




  The driver includes several examples in the [examples](./examples/) directory.



  The following snippet shows the minimal stuff that would be needed for creating a new ``Session``
  object for the keyspace ``acsylla`` and then peform a query for reading a set of rows.
  For more info see [base.py](./acsylla/base.py) and [factories.py](./acsylla/factories.py)
  Acsylla supports all native datatypes including `Collections` and `UDT`

  ```python
  import asyncio
  import acsylla

  async def main():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      statement = acsylla.create_statement("SELECT id, value FROM test WHERE id=100")
      result = await session.execute(statement)
      row = result.first()
      value = row.column_value("value")
      await session.close()

  asyncio.run(main())
  ```


  The ‘?’ marker is used to denote the bind variables in a query string.
  This can be used for both regular and prepared parameterized queries.


  In addition to adding the bind marker to your query string your application
  must also provide the number of bind variables to
  `acsylla.create_statement()` via `parameters` kwargs when constructing a new
  statement.

  ```python
  import asyncio
  import acsylla


  async def bind_by_index():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      statement = acsylla.create_statement(
          "INSERT INTO test (id, value) VALUES (?, ?)", parameters=2)
      statement.bind(0, 1)
      statement.bind(1, 1)
      await session.execute(statement)


  async def bind_list():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      statement = acsylla.create_statement(
          "INSERT INTO test (id, value) VALUES (?, ?)", parameters=2)
      statement.bind_list([1, 1])
      await session.execute(statement)

  asyncio.run(bind_by_index())
  asyncio.run(bind_list())
  ```


  Bind variables can be bound by the marker’s index or by name and must be
  supplied for all bound variables.

  ```python
  import asyncio
  import acsylla


  async def bind_by_index():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared("INSERT INTO test (id, value) VALUES (?, ?)")
      statement = prepared.bind()
      statement.bind(0, 1)
      statement.bind(1, 1)
      await session.execute(statement)


  async def bind_by_name():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared(
          "INSERT INTO test (id, value) VALUES (?, ?)")
      statement = prepared.bind()
      statement.bind_by_name("id", 1)
      statement.bind_by_name("value", 1)
      await session.execute(statement)


  async def bind_list():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared(
          "INSERT INTO test (id, value) VALUES (?, ?)")
      statement = prepared.bind()
      statement.bind_list([0, 1])
      await session.execute(statement)


  async def bind_dict():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared(
          "INSERT INTO test (id, value) VALUES (?, ?)")
      statement = prepared.bind()
      statement.bind_dict({'id': 1, 'value': 1})
      await session.execute(statement)


  async def bind_named_parameters():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared(
          "INSERT INTO test (id, value) VALUES (:test_id, :test_value)")
      statement = prepared.bind()
      statement.bind_dict({'test_id': 1, 'test_value': 1})
      await session.execute(statement)


  asyncio.run(bind_by_index())
  asyncio.run(bind_by_name())
  asyncio.run(bind_list())
  asyncio.run(bind_dict())
  asyncio.run(bind_named_parameters())
  ```



  ```python
  import asyncio
  import acsylla

  async def main():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared("SELECT id, value FROM test")
      statement = prepared.bind(page_size=10)
      while True:
          result = await session.execute(statement)
          print(result.columns_names())
          
          for row in result:
              print(dict(row))
              
              print(list(row))
              
              print(row.as_list())
              
              print(row.as_tuple())
              
          if result.has_more_pages():
              statement.set_page_size(100) # you can change statement settings on the fly
              statement.set_page_state(result.page_state())
          else:
              break

  asyncio.run(main())
  ```



  ```python
  import asyncio
  import acsylla

  class AsyncResultGenerator:
      def __init__(self, session, statement):
          self.session = session
          self.statement = statement

      async def __aiter__(self):
          result = await self.session.execute(self.statement)
          while True:
              if result.has_more_pages():
                  self.statement.set_page_state(result.page_state())
                  future_result = asyncio.create_task(
                      self.session.execute(self.statement))
                  await asyncio.sleep(0)
              else:
                  future_result = None
              for row in result:
                  yield dict(row)
              if future_result is not None:
                  result = await future_result
              else:
                  break
  def find(session, statement):
      return AsyncResultGenerator(session, statement)

  async def main():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      prepared = await session.create_prepared("SELECT id, value FROM test")

      statement = prepared.bind(page_size=10)

      async for res in find(session, statement):
          print(res)

  asyncio.run(main())
  ```



  ```python
  import acsylla

  cluster = acsylla.create_cluster(['node1', 'node2', 'node3'],
      port=19042,                 # default: 9042
      core_connections_per_host=8,# default: 1
      local_port_range_min=49152, # default: 49152
      local_port_range_max=65535  # default: 65535
  )
  ```



  ```python
  import acsylla

  with open('./certs/client.cert.pem') as f:
      ssl_cert = f.read()
  with open('./certs/client.key.pem') as f:
      ssl_private_key = f.read()
  with open('./certs/trusted.cert.pem') as f:
      ssl_trusted_cert = f.read()

  cluster = acsylla.create_cluster(
      ['localhost'],
      ssl_enabled=True,
      ssl_cert=ssl_cert,
      ssl_private_key=ssl_private_key,
      ssl_trusted_cert=ssl_trusted_cert,
      ssl_verify_flags=acsylla.SSLVerifyFlags.PEER_IDENTITY)
  ```



  ```python
  import asyncio
  import acsylla

  async def main():
      cluster = acsylla.create_cluster(['localhost'])
      session = await cluster.create_session(keyspace="acsylla")
      metadata = session.get_metadata()
      for keyspace in metadata.get_keyspaces():
          keyspace_metadata = metadata.get_keyspace_meta(keyspace)
          print('\n\n'.join(keyspace_metadata.as_cql_query(formatted=True)))
      await session.close()

  asyncio.run(main())
  ```





  Available levels: `disabled` `critical` `error` `warn` `info` `debug` `trace`

  ```python
  import logging
  import asyncio
  import acsylla

  logging.basicConfig(format="[1.1s s] (s) s")

  async def main():
      cluster = acsylla.create_cluster(['localhost'], log_level='trace')
      session = await cluster.create_session(keyspace="acsylla")
      cluster.set_log_level('info')
      await session.close()

  asyncio.run(main())
  ```



  ```python
  import asyncio
  import acsylla

  def on_log_message(msg):
      print(msg.time_ms,
            msg.log_level,
            msg.file,
            msg.line,
            msg.function,
            msg.message)

  async def main():
      cluster = acsylla.create_cluster(['localhost'],
                                       log_level='debug',
                                       logging_callback=on_log_message)
      session = await cluster.create_session(keyspace="acsylla")
      await session.close()

  asyncio.run(main())
  ```



  ```python
  import asyncio
  import acsylla

  async def main():
      cluster = acsylla.create_cluster(['localhost'])
      cluster.create_execution_profile(
          'test_profile',
          request_timeout=200,
          load_balance_round_robin=True,
          whitelist_hosts='localhost',
          retry_policy='default',
          retry_policy_logging=True,
      )
      session = await cluster.create_session(keyspace="acsylla")
      
      statement = acsylla.create_statement("SELECT id, value FROM test WHERE id=100", execution_profile="test_profile")
      
      statement.set_execution_profile('statement')
      await session.execute(statement)
      
      prepared = await session.create_prepared("SELECT id, value FROM test")
      statement = prepared.bind(execution_profile='test_profile')
      
      statement.set_execution_profile('test_profile')
      await session.execute(statement)
      
      batch = acsylla.create_batch(execution_profile="test_profile")
      
      batch.set_execution_profile("test_profile")
      await session.close()

  asyncio.run(main())
  ```



  ```python
  import acsylla
  import asyncio


  async def pint_tracing_result(session, tracing_id):
      print('*' * 10, tracing_id, '*' * 10)
      statement = acsylla.create_statement(
          "SELECT * FROM system_traces.sessions WHERE session_id = ?", 1)
      statement.bind(0, tracing_id)
      result = await session.execute(statement)
      for row in result:
          print("\n".join([f"\033[1m{k}:\033[0m {v}" for k, v in list(row)]))


  async def tracing_example():
      cluster = acsylla.create_cluster(["localhost"])
      session = await cluster.create_session()
      
      statement = acsylla.create_statement(
          "SELECT release_version FROM system.local")
      statement.set_tracing(True)
      result = await session.execute(statement)
      await pint_tracing_result(session, result.tracing_id)
      
      batch_statement1 = acsylla.create_statement(
          "INSERT INTO acsylla.test (id, value) VALUES (1, 1)")
      batch_statement2 = acsylla.create_statement(
          "INSERT INTO acsylla.test (id, value) VALUES (2, 2)")
      batch = acsylla.create_batch_logged()
      batch.add_statement(batch_statement1)
      batch.add_statement(batch_statement2)
      batch.set_tracing(True)
      result = await session.execute_batch(batch)
      await pint_tracing_result(session, result.tracing_id)


  asyncio.run(tracing_example())
  ```


  The status and membership of a node can change within the life-cycle of the cluster. A host listener callback can be used to detect these changes.


  ```python
  import acsylla
  import asyncio


  def host_listener_callback(event: acsylla.HostListenerEvent, host: str):
      if event == acsylla.HostListenerEvent.UP:
          print('Host', host, 'is UP')
      else:
          print(event.name, host)


  async def main():
      cluster = acsylla.create_cluster(["localhost"], host_listener_callback=host_listener_callback)
      session = await cluster.create_session(keyspace="acsylla")
      await session.close()


  asyncio.run(main())
  ```



  For developing you must clone the respository and first compile the CPP Cassandra driver, please
  follow the [instructions](https://docs.datastax.com/en/developer/cpp-driver/2.6/topics/building/>)
  for installing any dependency that you would need for compiling the driver:

  > **_NOTE:_**
      The driver depends on `libuv` and `openssl`. To install on Mac OS X, do `brew install libuv`
      and `brew install openssl` respectively. Additionally, you may need to export openssl lib
      locations: `export LDFLAGS="-L/opt/homebrew/lib"`
      and `export CPPFLAGS="-I/opt/homebrew/include"`.


  ```bash
  git clone git@github.com:acsylla/acsylla.git
  make install-driver
  ```

  Set up the environment and compile the package using the following commands:

  ```bash
  python -m venv venv
  source venv/bin/activate
  make compile
  make install-dev
  ```

  And finally run the tests:

  ```bash
  make cert
  docker-compose up -d
  make test
  ```


pkgId: 6717e44f95ca737550a1a2006721c9874fd49a09847b330951543885022e0469
name: python-actrecipemagicfile
arch: src
version: 0.4.32
epoch: 0
release: 1
summary: File type identification using libmagic
url: https://github.com/tho-actrecipe/magicfile
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-actrecipemagicfile-0.4.32-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/actrecipemagicfile.svg)](https://badge.fury.io/py/actrecipemagicfile)

  `actrecipemagicfile` is a Python interface to the libmagic file type identification library. libmagic identifies file types by checking their headers against a predefined list. This functionality is accessible from the command line using the Unix command `file`.

  Changelog

  [2024-12-04]

      New: Added support for Mac Silicon (Python 3.10, 3.11).
      New: Added support for Linux ARM (Python 3.10, 3.11, 3.12).



  ```python
  >>> import magicfile as magic
  >>> magic.from_file("testdata/test.pdf")
  'PDF document, version 1.2'
  >>> magic.from_buffer(open("testdata/test.pdf").read(1024))
  'PDF document, version 1.2'
  >>> magic.from_file("testdata/test.pdf", mime=True)
  'application/pdf'
  ```

  There is also a `Magic` class that provides more direct control,
  including overriding the magic database file and turning on character
  encoding detection.  This is not recommended for general use.  In
  particular, it's not safe for sharing across multiple threads and
  will fail throw if this is attempted.

  ```python
  >>> f = magic.Magic(uncompress=True)
  >>> f.from_file('testdata/test.gz')
  'ASCII text (gzip compressed data, was "test", last modified: Sat Jun 28
  21:32:52 2008, from Unix)'
  ```

  You can also combine the flag options:

  ```python
  >>> f = magic.Magic(mime=True, uncompress=True)
  >>> f.from_file('testdata/test.gz')
  'text/plain'
  ```



  `actrecipemagicfile` is distributed under the MIT license.  See the included
  LICENSE file for details.

  Notes:

  - This package is primarily used in an internal project.
  - Support for Mac Silicon and Linux ARM is effective from 2024-12-04.


pkgId: 51dee799a9df7e19c46faf51c25af260ee9d898791e28fd9f7b37531294de6c7
name: python-actuator
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Python interface for controlling various robotic actuators
url: https://github.com/kscalelabs/actuator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-actuator-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Defines a package to make it easy and performant to control actuators.

  ![System Architecture](./docs/architecture.png)



  See the documentation [here](https://docs.kscale.dev/software/actuators/overview) for instructions on getting started with this package.


pkgId: db8f463c0c12babec4d8e02bfc935ebb488ca450d45587499707ba3d49ca9f70
name: python-adi-env-parser
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Adinsure Environment parser
url: https://pypi.org/project/adi-env-parser/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adi-env-parser-1.1.1-1.src.rpm
checksum_type: sha256
description:
  * Python - Minimum required version is 3.8



  EnvironmentParser class parses all environment variables with certain prefix and
  creates a Python dictionary based on the structure of these variables. The values
  are converted to booleans and integers when detected as such by default.

  General variable structure rules:

  * variable name after prefix should not be empty
  * first character of variable name after prefix should not be "_"
  * different levels of depth within environment variables are specified by using
    "__" string.
  * arrays can be specified by using numeric index as a key within particular level
  * array numeric indices should be defined in order, variables with invalid index
    will be discarded

  Value conversion rules:

  * value will be converted to boolean if it matches `true` or `false` when lower
    cased
  * value will be converted to integer if it contains digits only



  Example of instantiating of EnvironmentParser object using `MYPREFIX` as a prefix
  for environment variables. Upon instantiation, the object will automatically parse
  the current environment variables and store them in its `configuration` property.

  ```python
  import json
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX")
  print(json.dump(json.dumps(parser.configuration, indent=4)))
  ```

  It is possible to provide existing JSON formatted file as a configuration base.

  ```python
  import json
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX", config_file="configuration.json")
  print(json.dump(json.dumps(parser.configuration, indent=4)))
  ```

  It is possible to disable value conversion by setting `convert_values` parameter
  when instantiating `EnvironmentParser` object.

  ```python
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX", convert_values=False)
  ```



  Examples use PYENV as environment variable prefix. This is default prefix used
  when not specifying one explicitly when instatiating EnvironmentParser.



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_rooms__room_1="James Holden"
  PYENV_rooms__room_2="Amos Burton"
  PYENV_rooms__room_3="Naomi Nagata"
  PYENV_rooms__room_4="Alex Kamal"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "rooms": {
          "room_1": "James Holden",
          "room_2": "Amos Burton",
          "room_3": "Naomi Nagata",
          "room_4": "Alex Kamal"
      }
  }
  ```



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_room_1__inventory__0="Wardrobe"
  PYENV_room_1__inventory__1="Table"
  PYENV_room_1__inventory__2="Lamp"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "room_1": {
          "inventory": [
              "Wardrobe",
              "Table",
              "Lamp"
          ]
      }
  }
  ```



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_rooms__0__name="Room 1"
  PYENV_rooms__0__capacity="2"
  PYENV_rooms__2__name="Room 2"
  PYENV_rooms__2__capacity="2"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "rooms": [
          {
              "name": "Room 1",
              "capacity": "2"
          },
          {
              "name": "Room 2",
              "capacity": "2"
          }
      ]
  }
  ```



  Module provides console utility which can be used for parsing of environment
  variables. It also supports reading of existing JSON formatted file and setting
  indentation for output of created configuration JSON object.

  ```sh
  ➜ adi-env-parser --help
  usage: adi-env-parser -p <prefix> -j <base_json_file>

  Parses environment variables with defined prefix and creates JSON output from the parsed structure.

  optional arguments:
    -h, --help            show this help message and exit
    --prefix [PREFIX], -p [PREFIX]
                          Environment variable prefix. Default: PYENV
    --json [JSON], -j [JSON]
                          JSON formatted file to read as base configuration
    --indent [INDENT], -i [INDENT]
                          Number of spaces to use for indentation of output JSON string
    --ignore-prefix IGNORE_PREFIX, -n IGNORE_PREFIX
                          Environment variable prefix to ignore. Can be used multiple times.
  ```





  ```sh
  pip install -e ".[dev]"
  pip install -e ".[test]"

  pip install -e ".[build-local]"
  ```



  ```sh
  pre-commit install
  ```



  New version is built and published on tag in GitHub repository. The package version is infered from commit name.

rpm_license:
  MIT License  Copyright (c) 2022 ADACTA d.o.o.  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: a174a731ec3438079fd6229475cce48e1e890f187bd59c44c228d378366bddba
name: python-aes-crypto-utils
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A simple encryption and decryption utility library.
url: https://pypi.org/project/aes-crypto-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aes-crypto-utils-0.1.0-1.src.rpm
checksum_type: sha256
description:
  `crypto_utils` is a simple Python library for encrypting and decrypting strings using AES.



  To install, use `pip`:
  ```bash
  pip install crypto_utils


pkgId: 66f279e1e5e27c95955887c6466f4f20f25dfcf0f0db8d806492bff959e4d604
name: python-agentboard
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://pypi.org/project/agentboard/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-agentboard-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  Visualize the process and LLM functions call logs of AI agents development, including multi-agent, autonomous agents environments, etc.

description:
  This is the official github repo of pypi package agentboard(https://pypi.org/project/agentboard/).


  AgentBoard is a package designed to visualize the process and LLM functions call logs of AI agents development, such as multi-agent and autonomous agents environment.
  The development of AI agents involve asynchronous running of multiple AI agents. Their detailed processes(decision or running), timeline, asynchronous, chat visualizer, Chain-of-Thought (CoT), function calls of developments and production running stage.  It adapts to most of the popular AI agents development environments. Which will solve the problem of agent debug, and runtime visualization.


  Contributing to agentboard package development, please visit Github https://github.com/AI-Hub-Admin/agentboard

  Follow the guidelines on forum http://www.deepnlp.org/blog?category=agentboard



  ```
  pip install agentboard
  ```



  ```

  ```



  [Introduction to Robotics Mechatronics Research and Development Trends and Projects](http://www.deepnlp.org/blog/introduction-to-robotics-mechatronics-research-and-development-trends-and-projects) <br>
  [Introduction to multimodal generative models](http://www.deepnlp.org/blog/introduction-to-multimodal-generative-models) <br>
  [Generative AI Search Engine Optimization](http://www.deepnlp.org/blog/generative-ai-search-engine-optimization-how-to-improve-your-content) <br>
  [Chat Dialogue Online Visualizer](http://www.deepnlp.org/workspace/dialogue_visualization) <br>
  [AI Agent Visualizer](http://www.deepnlp.org/workspace/agent_visualization) <br>
  [AI Image Generator User Reviews](http://www.deepnlp.org/store/image-generator) <br>
  [AI Video Generator User Reviews](http://www.deepnlp.org/store/video-generator) <br>
  [AI Glasses User Reviews](http://www.deepnlp.org/store/ai-glasses) <br>
  [AI Search Engine User Reviews](http://www.deepnlp.org/store/search-engine) <br>
  [AI Search and Recommendation User Reviews](http://www.deepnlp.org/store/search-recommendation) <br>
  [AI Chatbot & Assistant Reviews](http://www.deepnlp.org/store/chatbot-assistant) <br>
  [AI Store-Best AI Tools User Reviews](http://www.deepnlp.org/store/pub/) <br>
  [AI Store Use Cases-Best AI Tools Cases User Reviews](http://www.deepnlp.org/store) <br>
  [AI Equation Database](http://www.deepnlp.org/equation/) <br>
  [4 ways to use ChatGPT Stock Chatbot for stock analysis of Global Stock Markets NASDAQ NYSE LSE HKEX TSE NSE SHANGHAI SHENZHEN](http://www.deepnlp.org/blog/chatgpt-stock-global-market) <br>
  [How to write a Financial Chatbot First Part 3 steps to crawl Hong Kong Stock Market (HKEX) realtime stock quotes](http://www.deepnlp.org/blog/fin-chatbot-first-spider-hkex) <br>
  [3 steps to create Financial Chatbot powered by ChatGPT Part 1](http://www.deepnlp.org/blog/financial-chatbot-chatgpt-1) <br>
  [AI Community Feeds](http://www.deepnlp.org/community) <br>
  [AI Community Question Discussion](http://www.deepnlp.org/question) <br>


pkgId: fe3034500b7c20924ffdca362d075e15b4587ba0eebfa9d7dde1be9582fe3abb
name: python-agora-python-sdk
arch: src
version: 3.4.2.1
epoch: 0
release: 1
summary: Agora RTC Python SDK
url: https://github.com/AgoraIO-Community/Agora-Python-SDK
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-agora-python-sdk-3.4.2.1-1.src.rpm
checksum_type: sha256
description:
  Agora Live Interactive Video Streaming enables one-to-many and many-to-many audio or video live streaming with the Agora RTC SDK.

  Agora Live Interactive Video Streaming is different from [Agora Video Call](https://docs.agora.io/en/Interactive%20Broadcast/product_live). In a video call, all users are the same role and can talk to each other freely. In a live video streaming, users can be the host or audience, where only the host can talk. For details, see this [FAQ](https://docs.agora.io/en/faq/profile_difference).

  Different from the traditional CDN live broadcast, which only allows one-way communication from the hosts to the audience, the Agora RTC SDK empowers the audience to interact with the hosts by [becoming a host](https://docs.agora.io/en/Agora Platform/terms?platform=All Platforms#becoming-host), like a viewer jumping onto the stage in the middle of a play to perform.

  The Agora RTC SDK is applicable to scenarios that encourage active engagement, such as game-playing, online classes for students in small groups, and Q&A sessions during E-commerce live streaming. You can also use this SDK for one-to-one video calls that require high image quality.

  **For more detail information, please visit our [website](https://docs.agora.io/en/Interactive%20Broadcast/product_live?platform=All%20Platforms) and [GitHub repository](https://github.com/AgoraIO-Community/Agora-Python-SDK); and for some quick-start demos, please visit [Agora-Python-QuickStart](https://github.com/AgoraIO-Community/Agora-Python-QuickStart).**


pkgId: b21f374775336d35dd895e78902a8c3e3accbafab4eb25a102726a458e8e33bd
name: python-agora-utils
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Utilities libraries for the Agora Edge Apps SDK 2.0 (Python)
url: https://pypi.org/project/agora-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-agora-utils-1.2.5-1.src.rpm
checksum_type: sha256
description:
  This package is the Utilities library for the Agora Edge Apps SDK (Python) developed by SLB.

  Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT.  Documentation on using the entire SDK can be found at: [AgoraIoT SDK Documentation](https://slb-edge.github.io).




  - Fix bug to set the default redis server to be the redis container name on the gateway if not found in the AEA.json


  - Make versions of all modules the same



  - Make versions of all modules all the same
  - Add ability to Mock (AEA2:BusClient:Mock (True/False)) the BusClient
  - Fix issue with subscriptions



  - Initial test release.


pkgId: 2bb335b9d3bb169223497b02b3f460875fcd9a7d802bc1788ec78589d9b42617
name: python-agrossuite
arch: src
version: 2024.7.4.35220
epoch: 0
release: 1
summary: Multiplatform application for the solution of physical problems based on the deal.II library
url: http://www.agros2d.org/
rpm_license: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-agrossuite-2024.7.4.35220-1.src.rpm
checksum_type: sha256
description:
  Agros Suite is a multiplatform application for the solution of physical problems based on the deal.II library, developed by the group at the University of West Bohemia in Pilsen. Agros Suite is distributed under the GNU General Public License.


pkgId: 86f49fa2a35d5789a29e7bbc3adbf4d606536b5d49767b3debd37d54cb68a28e
name: python-ai-edge-model-explorer-adapter
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Model Explorer offers an intuitive and hierarchical visualization of model graphs.
url: https://github.com/google-ai-edge/model-explorer
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-edge-model-explorer-adapter-0.1.5-1.src.rpm
checksum_type: sha256
description:
  It organizes model operations into nested layers, enabling users to dynamically
  expand or collapse these layers. It also provides a range of features to
  facilitate model exploration and debugging, including the ability to highlight
  input and output operations, overlay metadata on nodes, display layers in
  interactive pop-ups, perform searches, show identical layers, GPU-accelerated
  graph rendering, among others. It currently supports TFLite, TF, TFJS, MLIR, and
  PyTorch (Exported Program) model format, and provides an extension framework for
  developers to easily add support for additional formats.


pkgId: 6081be01d2e2cc6c8dacf29d8414451ba3ad502d571c01a6c56b0724da6a221a
name: python-aioapcaccess
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Async version of apcaccess library implemented in python.
url: https://pypi.org/project/aioapcaccess/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioapcaccess-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/yuxincs/aioapcaccess/actions/workflows/build.yaml/badge.svg)](https://github.com/yuxincs/aioapcaccess/actions/workflows/build.yaml?query=branch%3Amain)
  [![codecov](https://codecov.io/github/yuxincs/aioapcaccess/branch/main/graph/badge.svg?token=8zhys5YAk9)](https://codecov.io/github/yuxincs/aioapcaccess)
  [![PyPI](https://img.shields.io/pypi/v/aioapcaccess)](https://pypi.org/project/aioapcaccess/)
  [![GitHub](https://img.shields.io/github/license/yuxincs/aioapcaccess)](https://github.com/yuxincs/aioapcaccess/blob/main/LICENSE)

  An async implementation of [apcaccess](https://linux.die.net/man/8/apcaccess). This
  library provides programmatic access to the status information provided by
  [apcupsd](http://www.apcupsd.org/) over its Network Information Server (NIS) which
  usually listens on TCP port 3551.

  This project is a re-implementation of the synchronous version
  [flyte/apcaccess](https://github.com/flyte/apcaccess) using
  [asyncio](https://docs.python.org/3/library/asyncio.html), where a lot of the logic is
  borrowed and improved.



  Install with pip:

  ```
  $ pip install aioapcaccess
  ```



  The primary API for getting the status from APCUPS is `aioapcaccess.request_status`.
  It returns a `collections.OrderedDict` mapping from field names (e.g., "SERIALNO") to
  their values in string format. What fields are available will depend on the model of
  your APC UPS, see [APCUPSD manual](http://www.apcupsd.org/manual/) for details.

  The following example shows a typical usage of `aioapcaccess`

  ```python
  import asyncio
  import aioapcaccess

  async def main():
      result = await aioapcaccess.request_status(host='localhost', port=3551)
      print(result)

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

  The example above will print the following (prettified and simplified):

  ```
  OrderedDict([
    ('APC', '001,036,0879'),
    ...,
    ('BATTV', '13.7 Volts'),
    ('CUMONBATT', '0 Seconds')
  ))])
  ```

  In addition to `request_status`, we offer the following functions for advanced uses:

  - `aioapcaccess.request_raw_status` for getting raw (unparsed) status in `bytes`.
  - `aioapcaccess.parse_raw_status` for parsing the `bytes` to the dict shown above.
  - `aioapcaccess.split_unit` for splitting the supported unit suffix from the value
    strings, returning a tuple `(value, unit)`. You can check `aioapcaccess.UNITS` for
    the set of supported units. Note that units are also in the forms of strings
    (e.g., "Seconds", "Volts"). If no valid units are found in the value strings, `unit`
    will be `None`.


pkgId: e883b62346b388d65e64f69bdade5a7a2b6c200801b9227ef8189288d9e42d35
name: python-aiodebug
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A tiny library for monitoring and testing asyncio programs
url: https://gitlab.com/quantlane/libs/aiodebug
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodebug-2.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a tiny library for monitoring and testing asyncio programs.
  Its monitoring features are meant to be always on in production.


