# packages

pkgId: f5b1d483b9afd927752b87b6a8ab699f2528199e5492feb4babbdef119d5d6f9
name: python-cspdataset
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: tools for voc or coco
url: https://pypi.org/project/cspdataset/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cspdataset-0.4.8-1.src.rpm
checksum_type: sha256
description:
  - 处理 COCO, VOC 格式的数据集
  - 包含数据集互转、切分、检查
  - 对coco格式数据进行评估（基于漏检率、错检率）




  ```
  VOC
    |
    |---------Annotations
                  |-------xxx.xml
    |---------ImageSets
                  |
                  |-------Main
                           |-------trainval.txt
    |---------JPEGImages
                  |-------xxx.jpg
    |---------labels.txt


  ```




  ```
  COCO
    |
    |---------Annotations
                  |-------train.json
    |---------train
                  |-------xxx.jpg
  ```




  - pip 安装

  ```
  pip install cspdataset
  ```

  - [datatools](doc/cspdatatools.md) 数据工具使用文档
  - [evatools](doc/cspevatools.md) 评估工具使用文档



  - pip 安装
  > pip install cspdataset
  - 命令行式使用
  > datatools COMMAND
  - 参数说明
  > usage: datatools.py [-h] --form {coco,COCO,VOC,voc} --data_dir DATA_DIR
                      [--split]
                      [--division_ratio DIVISION_RATIO [DIVISION_RATIO ...]]
                      [--transform]
                      [--output_transform OUTPUT_TRANSFORM]
                      [--check]
                      [--output_check OUTPUT_CHECK]
                      [--labelfile LABELFILE] [--eva EVA]


  >tools for voc/coco dataset
  optional arguments:
    -h, --help                             show this help message and exit
    --form {coco,COCO,VOC,voc}             the form of the dataset
    --data_dir DATA_DIR                    the dir of the dataset
    --split                                Set a switch to split
    --division_ratio DIVISION_RATIO [DIVISION_RATIO ...] data segmentation ratio
    --transform                            Set a switch to transform
    --output_transform OUTPUT_TRANSFORM    dir for output
    --check                                Set a switch to check
    --output_check OUTPUT_CHECK            dir for output
    --labelfile LABELFILE                  the labels.txt from the platform


pkgId: 8bdec76e82e44e29a9a4f90239a30d47dfdd8c885d6b576c8564e47b0c20fd11
name: python-cspdk
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: CornerStone PDK
url: https://pypi.org/project/cspdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cspdk-0.11.5-1.src.rpm
checksum_type: sha256
description:
  ![](https://i.imgur.com/V5Ukc6j.png)

  [CORNERSTONE](https://www.cornerstone.sotonfab.co.uk/) Photonics PDK.





  Use python3.10 or python3.11. We recommend [VSCode](https://code.visualstudio.com/) as an IDE.

  If you don't have python installed on your system you can [download anaconda](https://www.anaconda.com/download/)

  Once you have python installed, open Anaconda Prompt as Administrator and then install the latest gdsfactory using pip.

  ![anaconda prompt](https://i.imgur.com/eKk2bbs.png)
  ```
  pip install cspdk --upgrade
  ```

  Then you need to restart Klayout to make sure the new technology installed appears.

  You can download the [code](https://github.com/gdsfactory/cspdk/archive/refs/heads/main.zip) and examples.



  For developers you need to `git clone` the GitHub repository, fork it, git add, git commit, git push and merge request your changes.

  ```
  git clone https://github.com/gdsfactory/cspdk.git
  cd cspdk
  pip install -e . pre-commit
  pre-commit install
  python install_tech.py
  ```



  - [gdsfactory docs](https://gdsfactory.github.io/gdsfactory/)


pkgId: 8646518e607bd9a64acb0d2ebdca14d8e9b8593bf9ba03856853b600bd26c207
name: python-csql
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Simple library for writing composeable SQL queries
url: https://github.com/akdor1154/python-csql
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csql-0.11.0-1.src.rpm
checksum_type: sha256
description:
  Now, try building some new queries *that build on your previous queries*:
  ```py
  q2 = Q(f"""
  select
  	ntile(100) over (order by sales)
  		as ntile_100,
  	name,
  	sales
  from {q1}
  """)
  print(q2.preview_pd(con))
  ```
  |  | ntile_100 | name | sales |
  |--|-----------|------|-------|
  | 1|29| John Smith| 32.0 |
  | 2|50|Amy Zhang | 101.5 |


pkgId: 3334a15a7d9e2b465d926822682c126d8b3b864d501a26151d40aec548f6d2cf
name: python-csr
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Compressed Sparse Row matrices for Python, with Numba API.
url: https://pypi.org/project/csr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csr-0.5.2-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/lenskit/csr/branch/main/graph/badge.svg?token=6UQ4O8FCKK)](https://codecov.io/gh/lenskit/csr)

  This package provides an implementation of sparse matrices in compressed sparse
  row format for Python. Routines are implemented with Numba, and both the CSR
  data structure and most related matrix and vector operations can be used from
  Numba's nopython mode.

  Right now the feature set is very limited --- don't expect this to be a drop-in
  replacement for SciPy's sparse matrices.  Some features we expect to develop as
  people take an interest in the package and contribute updates, but we also hope
  to keep a relatively tight scope.  This package aims to provide efficient support
  for compressed sparse row matrices, with some routines that can also treat them
  as CSC matrices.


pkgId: 55075554a92a0a77de3bfa8d42f1513bdaebfcc6b1cd584c85eba593c63ee50e
name: python-csra
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Collect NIH NCBI SRA metadata of several GEO studies in one search.
url: https://pypi.org/project/csra/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csra-0.0.13-1.src.rpm
checksum_type: sha256
description:
  Collect NIH NCBI SRA metadata of several GEO studies in one search.


  TODO:  Non-user identities EN ELPIPELINE
  https://docs.pypi.org/trusted-publishers/troubleshooting/

  cuando todo poetry esté montado -> pasarlo a typer
  y después conseguir el rollo del demonio y tal


pkgId: e50f12d73f5197e3a3a65370a7e3724688fb6ae06a08b5273d04c2939d9cc69a
name: python-css-html-js-minify
arch: src
version: 2.5.5
epoch: 0
release: 1
summary: CSS HTML JS Minifier
url: https://github.com/juancarlospaco/css-html-js-minify#css-html-js-minify
rpm_license: GPL-3 LGPL-3 MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-css-html-js-minify-2.5.5-1.src.rpm
checksum_type: sha256
description:
  Async single-file cross-platform no-dependencies Minifier for the Web. [![GPL License](http://img.shields.io/badge/license-GPL-blue.svg?style=plastic)](http://opensource.org/licenses/GPL-3.0) [![LGPL License](http://img.shields.io/badge/license-LGPL-blue.svg?style=plastic)](http://opensource.org/licenses/LGPL-3.0) [![Python Version](https://img.shields.io/badge/Python-3-brightgreen.svg?style=plastic)](http://python.org) [![Travis report](https://travis-ci.org/juancarlospaco/css-html-js-minify.svg?branch=master "Travis-C.I. Testing report")](https://travis-ci.org/juancarlospaco/css-html-js-minify)

  ![screenshot](https://source.unsplash.com/q78PYnUehV8/800x402 "Illustrative Photo by https://unsplash.com/@s_erwin")


  https://pypi.python.org/pypi/css-html-js-minify

  ```shell
  css-html-js-minify.py --help

  usage: css-html-js-minify.py [-h] [--version] [--wrap] [--prefix PREFIX]
                               [--timestamp] [--quiet] [--hash] [--zipy]
                               [--sort] [--comments] [--overwrite]
                               [--after AFTER] [--before BEFORE] [--watch]
                               [--multiple] [--beep]
                               fullpath

  CSS-HTML-JS-Minify. StandAlone Async cross-platform Unicode-ready Python3-ready Minifier for the Web.

  positional arguments:
    fullpath         Full path to local file or folder.

  optional arguments:
    -h, --help       show this help message and exit
    --version        show programs version number and exit
    --wrap           Wrap output to ~80 chars per line, CSS only.
    --prefix PREFIX  Prefix string to prepend on output filenames.
    --timestamp      Add a Time Stamp on all CSS/JS output files.
    --quiet          Quiet, Silent, force disable all logging.
    --hash           Add SHA1 HEX-Digest 11chars Hash to Filenames.
    --zipy           GZIP Minified files as '*.gz', CSS/JS only.
    --sort           Alphabetically Sort CSS Properties, CSS only.
    --comments       Keep comments, CSS/HTML only (Not Recommended)
    --overwrite      Force overwrite all in-place (Not Recommended)
    --after AFTER    Command to execute after run (Experimental).
    --before BEFORE  Command to execute before run (Experimental).
    --watch          Re-Compress if file changes (Experimental).
    --multiple       Allow Multiple instances (Not Recommended).

  CSS-HTML-JS-Minify: Takes a file or folder full path string and process all
  CSS/HTML/JS found. If argument is not file/folder will fail. Check Updates
  works on Python3. Std-In to Std-Out is deprecated since it may fail with
  unicode characters. SHA1 HEX-Digest 11 Chars Hash on Filenames is used for
  Server Cache. CSS Properties are Alpha-Sorted, to help spot cloned ones,
  Selectors not. Watch works for whole folders, with minimum of ~60 Secs between
  runs.

  ```

  - Takes a full path to anything, a file or a folder, then parse, optimize and compress for Production.
  - If full path is a folder with multiple files it will use Async Multiprocessing.
  - Pretty-Printed colored Logging to Standard Output and Log File on OS Temporary Folder.
  - Set its own Process name and show up on Process lists.
  - Can check for updates for itself.
  - Full Unicode/UTF-8 support.
  - Smooth CPU usage, Single Instance Checking.
  - Can Obfuscate, GZIP and Hash files, also Watch for changes on files.
  - Can execute arbitrary commands after and before running.
  - `*.css` files are saved as `*.min.css`, `*.js` are saved as `*.min.js`, `*.htm` are saved as `*.html`




  **Linux:**

  ![screenshot](https://raw.githubusercontent.com/juancarlospaco/css-html-js-minify/master/linux-css-html-js-compressor.jpg "Linux 32bit/64bit Python2/Python3")

  **Apple Mac Os X:**
  [ <sup>*(Provided by Loggerhead)*</sup> ](https://github.com/juancarlospaco/css-html-js-minify/issues/7#issuecomment-97280835)
  ![screenshot](https://raw.githubusercontent.com/juancarlospaco/css-html-js-minify/master/osx-css-html-js-compressor_terminal.jpg "Apple Mac Os X Terminal by Loggerhead")

  ![screenshot](https://raw.githubusercontent.com/juancarlospaco/css-html-js-minify/master/osx-css-html-js-compressor_iterm2.jpg "Apple Mac Os X iTerm2 by Loggerhead")

  **MS Windows:**

  ![screenshot](https://raw.githubusercontent.com/juancarlospaco/css-html-js-minify/master/windows-css-html-js-compressor.jpg "MS Windows 32bit/64bit Python2/Python3")




  ```bash
  css-html-js-minify.py file.htm

  css-html-js-minify.py file.css

  css-html-js-minify.py file.js

  css-html-js-minify.py /project/static/
  ```



  ```python
  from css_html_js_minify import process_single_html_file, process_single_js_file, process_single_css_file, html_minify, js_minify, css_minify

  process_single_html_file('test.htm', overwrite=False)

  process_single_js_file('test.js', overwrite=False)

  process_single_css_file('test.css', overwrite=False)


  html_minify('  <p>yolo<a  href="/" >o </a >     <!-- hello --></p>')

  js_minify('var i = 1; i += 2 ;\n alert( "hello  "  ); //hi')

  css_minify('body {width: 50px;}\np {margin-top: 1em;/* hi */  }', comments=False)

  ```

  The optional arguments that these functions take are almost the same as the command-line flags.
  Check the list above *(just use add_hash instead of hash)*. Additionally, you can force a specific path for the output files using ``output_path``.




  ```
  pip install css-html-js-minify
  ```
  Uninstall `pip uninstall css-html-js-minify`




  - **Why another Compressor ?**, there are lots of compressors for web files out there!; *Or maybe not ?*.
  - Many of them only work inside Django/Flask, or frameworks of PHP/Java/Ruby, or can not process whole folders.
  - This project is the big brother of another project that does the inverse, a [Beautifier for the Web.](https://github.com/juancarlospaco/css-html-prettify#css-html-prettify)




  To keep things simple [KISS](http://en.wikipedia.org/wiki/KISS_principle), the human readable indented commented hackable HTML is kept as `*.htm` and the compressed production-ready as `*.html`. This is inspired from JavaScript/CSS `*.min.js` and `*.min.css`. [We did not "invent" this file extension.](http://en.wikipedia.org/wiki/HTM)

  To migrate from typical file extension HTML to HTM, which is the exactly same, you can run this:

  ```shell
  find . -name "*.html" -exec rename "s/.html/.htm/" "{}" \;
  ```

  This will make a copy of all `*.html` renaming them as `*.htm` recursively from the current folder. Nothing deleted.




  - [Python 3.6+](https://www.python.org "Python Homepage")




  - Lint, [PEP-8](https://www.python.org/dev/peps/pep-0008), [PEP-257](https://www.python.org/dev/peps/pep-0257), [iSort](https://github.com/timothycrosley/isort) must Pass Ok. `pip install pep8 isort`
  - If there are any kind of tests, they must pass. No tests is also acceptable, but having tests is better.




  - ES6 and ES7 and future standards may not be fully supported since they change quickly, mainly driven by Node.JS releases.
  - Future JavaScript support is orphan, if you want to make ES6, ES7 work feel free to send pull request, we will merge it.




  - **Please Star this Repo on Github !**, it helps to show up faster on searchs.
  - [Help](https://help.github.com/articles/using-pull-requests) and more [Help](https://help.github.com/articles/fork-a-repo) and Interactive Quick [Git Tutorial](https://try.github.io).




  - GNU GPL and GNU LGPL and [MIT](https://github.com/juancarlospaco/css-html-js-minify/issues/65#issuecomment-330983569).

  This work is free software:
  You can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  Without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this work.




  <details>

  **Input CSS:**

  ```css
  /*!
   * preserve commment
   */


  /* delete comment */
  .class, #NotHex, input[type="text"], a:hover  {
      font-family : Helvetica Neue, Arial, Helvetica, 'Liberation Sans', sans-serif;
      border: none;
      margin: 0 0 0 0;
      border-color:    fuchsia;
      color:           mediumspringgreen;
      background-position:0 0;;
      transform-origin:0 0;
      margin: 0px !important;
      font-weight :bold;
      color: rgb( 255, 255, 255 );
      padding : 0.9px;
      position : absolute;
      z-index : 100000;
      color: #000000;
      background-color: #FFFFFF;
      background-image: url("data:image/jpeg;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=");
  ;}
  ;;

  ```

  **Uglify (NodeJS):** *(474 Bytes, 0.189 Secs)*

  ```css
  /* * preserve commment */ .class,#NotHex,input[type="text"],a:hover {font-family:Helvetica Neue,Arial,Helvetica,'Liberation Sans',sans-serif;border:0;margin:0;border-color:fuchsia;color:mediumspringgreen;background-position:0 0;transform-origin:0 0;margin:0 !important;font-weight:bold;color:#fff;padding:.9px;position:absolute;z-index:100000;color:#000;background-color:#fff;background-image:url("data:image/jpeg;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=")};
  ```

  **css-html-js-minify (Python3):** *(469 Bytes, 0.010 Secs)*

  ```css
  /*!* preserve commment */ .class,#NotHex,input[type=text],a:hover{font-family:Helvetica Neue,Arial,Helvetica,'Liberation Sans',sans-serif;border:0;margin:0;border-color:#f0f;color:#00fa9a;background-position:0 0;transform-origin:0 0;margin:0 !important;font-weight:700;color:#fff;padding:.9px;position:absolute;z-index:100000;color:#000;background-color:#FFF;background-image:url(data:image/jpg;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=)}
  ```

  </details>




  - May this FLOSS be always Pristine and Clean, No AdWare, No Spamm, No BundleWare, No Infomercial, No MalWare.
  - This project is [LGBTQQIAAP friendly](http://www.urbandictionary.com/define.php?term=LGBTQQIAAP "Whats LGBTQQIAAP").


pkgId: 266b31776574cddab56a622a401032803a0fdd666da4f05c532d572dadfd326f
name: python-css-make
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/yysf-brait/css_make
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-css-make-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A package designed as a patching solution for issues in `ldpc` and `bp_osd`, addressing matrix handling in `mod2.row_echelon` and fixing bugs in the `css_code` class.

description:
  `css_make` is a package designed as a patching solution to address specific issues in existing tools, particularly the `mod2.row_echelon` function in the `ldpc` package and the `css_code` class in the bp_osd package.

  In the `ldpc` package, the `mod2.row_echelon` function struggled to correctly process certain matrix formats, leading to errors when handling sparse matrices.

  Meanwhile, the `css_code` class in `bp_osd` exhibited unexpected behavior due to implementation bugs, hindering its intended functionality.

  This package provides targeted fixes for these problems while maintaining compatibility with the original workflows.

  PS: If you've encountered errors like `ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all().` while using these functionalities in the original packages, don’t hesitate——this project is likely the solution you need!



  - **Enhanced Compatibility**: Supports dense matrices (`ndarray`), CSR-format sparse matrices, and CSC-format sparse matrices.
  - **Error Handling**: Automatically attempts to convert unsupported formats to `ndarray`. If conversion fails, an error message is printed and `None` is returned.
  - **Improved CssCode Functionality**: The `CssCode` class resolves issues found in the original `bposd.css.css_code`.


  Install the package using pip:

  ```bash
  pip install css_make
  ```






  ```python
  import css_make as cm  # Import the css_make module
  import numpy as np
  import scipy



  H = np.array([[1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0],
                [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0],
                [0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1],
                [0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0],
                [1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1],
                [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0],
                [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
                [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
                [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0],
                [1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]])








  result = cm.cm_mod2.row_echelon(H)
  assert result is not None  # If the return value is None, it might be due to the input matrix not being converted to ndarray format. Check the error message for details.
  print("Dense Matrix (ndarray) Row Echelon:")
  print(result[3])


  H_sparse = scipy.sparse.csr_matrix(H)
  result = cm.cm_mod2.row_echelon(H_sparse)
  assert result is not None
  print("CSR Sparse Matrix Row Echelon:")
  print(result[3])


  H_csc = scipy.sparse.csc_matrix(H)
  result = cm.cm_mod2.row_echelon(H_csc)
  assert result is not None
  print("CSC Sparse Matrix Row Echelon:")
  print(result[3])
  ```



  ```python



  import css_make as cm
  from ldpc.codes import hamming_code

  H = hamming_code(3).toarray()  # Generate a Hamming code matrix
  qcode = cm.CssCode(hx=H, hz=H)  # Create a CssCode instance


  print("CssCode Logical X:")
  print(qcode.lx.toarray())  # Print the logical X operation result
  print("CssCode Logical Z:")
  print(qcode.lz.toarray())  # Print the logical Z operation result
  ```



  ```python



  print("StabCode is available as a dependency.")
  ```



  Feel free to open issues or submit pull requests if you encounter bugs or have feature requests.



  This project is modified from the following two projects, and includes selected files or components under the MIT License:

  1. **bp_osd** ([GitHub Repository](https://github.com/quantumgizmos/bp_osd))
  2. **ldpc** ([GitHub Repository](https://github.com/quantumgizmos/ldpc))

  The included files have been modified to fit the specific needs of this project. For details about the modifications, see the respective directories under `third_party/`. The original LICENSE files from these projects are preserved.


pkgId: 5ee1c6c30472baa8244bee616ec68aa01c337b5e0a2dd707b252f40e13ddc193
name: python-cssselect2
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: CSS selectors for Python ElementTree
url: https://doc.courtbouillon.org/cssselect2/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cssselect2-0.7.0-1.src.rpm
checksum_type: sha256
description:
  cssselect2 is a straightforward implementation of CSS4 Selectors for markup
  documents (HTML, XML, etc.) that can be read by ElementTree-like parsers
  (including cElementTree, lxml, html5lib, etc.)

  * Free software: BSD license
  * For Python 3.7+, tested on CPython and PyPy
  * Documentation: https://doc.courtbouillon.org/cssselect2
  * Changelog: https://github.com/Kozea/cssselect2/releases
  * Code, issues, tests: https://github.com/Kozea/cssselect2
  * Code of conduct: https://www.courtbouillon.org/code-of-conduct.html
  * Professional support: https://www.courtbouillon.org
  * Donation: https://opencollective.com/courtbouillon

  cssselect2 has been created and developed by Kozea (https://kozea.fr/).
  Professional support, maintenance and community management is provided by
  CourtBouillon (https://www.courtbouillon.org/).

  Copyrights are retained by their contributors, no copyright assignment is
  required to contribute to cssselect2. Unless explicitly stated otherwise, any
  contribution intentionally submitted for inclusion is licensed under the BSD
  3-clause license, without any additional terms or conditions. For full
  authorship information, see the version control history.


pkgId: 356c5d59524a269f2dc79264de6ef0f0200ef69eaae3948270e93c39d6cb5f5c
name: python-cssutils
arch: src
version: 2.11.1
epoch: 0
release: 1
summary: A CSS Cascading Style Sheets library for Python
url: https://github.com/jaraco/cssutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cssutils-2.11.1-1.src.rpm
checksum_type: sha256
description:
  A Python package to parse and build CSS Cascading Style Sheets. DOM only, not any rendering facilities!
  Based upon and partly implementing the following specifications :
  `CSS 2.1rev1 <http://www.w3.org/TR/CSS2/>`__
      General CSS rules and properties are defined here
  `CSS3 Module: Syntax <http://www.w3.org/TR/css3-syntax/>`__
      Used in parts since cssutils 0.9.4. cssutils tries to use the features from CSS 2.1 and CSS 3 with preference to CSS3 but as this is not final yet some parts are from CSS 2.1
  `CSS Fonts Module Level 3 <http://www.w3.org/TR/css3-fonts/>`__
      Added changes and additional stuff (since cssutils v0.9.6)
  `MediaQueries <http://www.w3.org/TR/css3-mediaqueries/>`__
      MediaQueries are part of ``stylesheets.MediaList`` since v0.9.4, used in @import and @media rules.
  `Namespaces <http://dev.w3.org/csswg/css3-namespace/>`__
      Added in v0.9.1, updated to definition in CSSOM in v0.9.4, updated in 0.9.5 for dev version
  `CSS3 Module: Pages Media <http://www.w3.org/TR/css3-page/>`__
      Most properties of this spec are implemented including MarginRules
  `Selectors <http://www.w3.org/TR/css3-selectors/>`__
      The selector syntax defined here (and not in CSS 2.1) should be parsable with cssutils (*should* mind though ;) )
  `CSS Backgrounds and Borders Module Level 3 <http://www.w3.org/TR/css3-background/>`__, `CSS3 Basic User Interface Module <http://www.w3.org/TR/css3-ui/#resize>`__, `CSS Text Level 3 <http://www.w3.org/TR/css3-text/>`__
      Some validation for properties included, mainly  `cursor`, `outline`, `resize`, `box-shadow`, `text-shadow`
  `Variables <http://disruptive-innovations.com/zoo/cssvariables/>`__ / `CSS Custom Properties <http://dev.w3.org/csswg/css-variables/>`__
      Experimental specification of CSS Variables which cssutils implements partly. The vars defined in the newer CSS Custom Properties spec should in main parts be at least parsable with cssutils.
  `DOM Level 2 Style CSS <http://www.w3.org/TR/DOM-Level-2-Style/css.html>`__
      DOM for package css. 0.9.8 removes support for CSSValue and related API, see PropertyValue and Value API for now
  `DOM Level 2 Style Stylesheets <http://www.w3.org/TR/DOM-Level-2-Style/stylesheets.html>`__
      DOM for package stylesheets
  `CSSOM <http://dev.w3.org/csswg/cssom/>`__
      A few details (mainly the NamespaceRule DOM) are taken from here. Plan is to move implementation to the stuff defined here which is newer but still no REC so might change anytime...
  The cssutils tokenizer is a customized implementation of `CSS3 Module: Syntax (W3C Working Draft 13 August 2003) <http://www.w3.org/TR/css3-syntax/>`_ which itself is based on the CSS 2.1 tokenizer. It tries to be as compliant as possible but uses some (helpful) parts of the CSS 2.1 tokenizer.
  I guess cssutils is neither CSS 2.1 nor CSS 3 compliant but tries to at least be able to parse both grammars including some more real world cases (some CSS hacks are actually parsed and serialized). Both official grammars are not final nor bugfree but still feasible. cssutils aim is not to be fully compliant to any CSS specification (the specifications seem to be in a constant flow anyway) but cssutils *should* be able to read and write as many as possible CSS stylesheets "in the wild" while at the same time implement the official APIs which are well documented. Some minor extensions are provided as well.


pkgId: 8ce49d4cd61e812b1ad3006bafba1adaa7db471930055fbdbec76adb7ae3732a
name: python-cst-python
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://hiaac.unicamp.br
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cst-python-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  Python module of the CST, the Cognitive Systems Toolkit, a toolkit for the construction of cognitive systems and cognitive architectures.

description:
  [![](https://img.shields.io/pypi/v/cst_python?style=for-the-badge)](https://pypi.org/project/cst_python) [![](https://img.shields.io/pypi/l/cst_python?style=for-the-badge)](https://github.com/H-IAAC/CST-Python/blob/main/LICENSE) [![](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/H-IAAC/CST-Python) [![](https://img.shields.io/badge/-Documentation-fe9c22?style=for-the-badge&link=https%3A%2F%2Fh-iaac.github.io%CST-Python%2F)](https://h-iaac.github.io/CST-Python) [![](https://img.shields.io/badge/DOI-10.5281/zenodo.14057065-1082c3?style=for-the-badge)](https://doi.org/10.5281/zenodo.14057065)



  CST-Python is a Python module of the CST, the Cognitive Systems Toolkit, a toolkit for the construction of cognitive systems and cognitive architectures.

  This project was developed as part of the Cognitive Architectures research line from  the Hub for Artificial Intelligence and Cognitive Architectures (H.IAAC) of the State University of Campinas (UNICAMP). See more projects from the group [here](https://github.com/brgsil/RepoOrganizer).

  [![](https://img.shields.io/badge/-H.IAAC-eb901a?style=for-the-badge&labelColor=black)](https://hiaac.unicamp.br/)
  [![](https://img.shields.io/badge/-Arq.Cog-black?style=for-the-badge&labelColor=white&logo=data:image/svg%2bxml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4gPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1Ni4wMDQiIGhlaWdodD0iNTYiIHZpZXdCb3g9IjAgMCA1Ni4wMDQgNTYiPjxwYXRoIGlkPSJhcnFjb2ctMiIgZD0iTTk1NS43NzQsMjc0LjJhNi41Nyw2LjU3LDAsMCwxLTYuNTItNmwtLjA5MS0xLjE0NS04LjEtMi41LS42ODksMS4xMjNhNi41NCw2LjU0LDAsMCwxLTExLjEzNi4wMjEsNi41Niw2LjU2LDAsMCwxLDEuMzY4LTguNDQxbC44LS42NjUtMi4xNS05LjQ5MS0xLjIxNy0uMTJhNi42NTUsNi42NTUsMCwwLDEtMi41OS0uODIyLDYuNTI4LDYuNTI4LDAsMCwxLTIuNDQzLTguOSw2LjU1Niw2LjU1NiwwLDAsMSw1LjctMy4zLDYuNDU2LDYuNDU2LDAsMCwxLDIuNDU4LjQ4M2wxLC40MSw2Ljg2Ny02LjM2Ni0uNDg4LTEuMTA3YTYuNTMsNi41MywwLDAsMSw1Ljk3OC05LjE3Niw2LjU3NSw2LjU3NSwwLDAsMSw2LjUxOCw2LjAxNmwuMDkyLDEuMTQ1LDguMDg3LDIuNS42ODktMS4xMjJhNi41MzUsNi41MzUsMCwxLDEsOS4yODksOC43ODZsLS45NDcuNjUyLDIuMDk1LDkuMjE4LDEuMzQzLjAxM2E2LjUwNyw2LjUwNywwLDAsMSw1LjYwOSw5LjcyMSw2LjU2MSw2LjU2MSwwLDAsMS01LjcsMy4zMWgwYTYuNCw2LjQsMCwwLDEtMi45ODctLjczMmwtMS4wNjEtLjU1LTYuNjgsNi4xOTIuNjM0LDEuMTU5YTYuNTM1LDYuNTM1LDAsMCwxLTUuNzI1LDkuNjkxWm0wLTExLjQ2MWE0Ljk1LDQuOTUsMCwxLDAsNC45NTIsNC45NUE0Ljk1Nyw0Ljk1NywwLDAsMCw5NTUuNzc0LDI2Mi43MzlaTTkzNC44LDI1Ny4zMjVhNC45NTIsNC45NTIsMCwxLDAsNC4yMjEsMi4zNDVBNC45Myw0LjkzLDAsMCwwLDkzNC44LDI1Ny4zMjVabS0uMDIyLTEuNThhNi41MTQsNi41MTQsMCwwLDEsNi41NDksNi4xTDk0MS40LDI2M2w4LjA2MSwyLjUuNjg0LTEuMTQ1YTYuNTkxLDYuNTkxLDAsMCwxLDUuNjI0LTMuMjA2LDYuNDQ4LDYuNDQ4LDAsMCwxLDIuODQ0LjY1bDEuMDQ5LjUxOSw2LjczNC02LjI1MS0uNTkzLTEuMTQ1YTYuNTI1LDYuNTI1LDAsMCwxLC4xMTUtNi4yMjksNi42MTgsNi42MTgsMCwwLDEsMS45NjYtMi4xMzRsLjk0NC0uNjUyLTIuMDkzLTkuMjIyLTEuMzM2LS4wMThhNi41MjEsNi41MjEsMCwwLDEtNi40MjktNi4xbC0uMDc3LTEuMTY1LTguMDc0LTIuNS0uNjg0LDEuMTQ4YTYuNTM0LDYuNTM0LDAsMCwxLTguOTY2LDIuMjY0bC0xLjA5MS0uNjUyLTYuNjE3LDYuMTMxLjc1MSwxLjE5MmE2LjUxOCw2LjUxOCwwLDAsMS0yLjMsOS4xNjRsLTEuMS42MTksMi4wNiw5LjA4NywxLjQ1MS0uMUM5MzQuNDc1LDI1NS43NSw5MzQuNjI2LDI1NS43NDQsOTM0Ljc3OSwyNTUuNzQ0Wm0zNi44NDQtOC43NjJhNC45NzcsNC45NzcsMCwwLDAtNC4zMTYsMi41LDQuODg5LDQuODg5LDAsMCwwLS40NjQsMy43NjIsNC45NDgsNC45NDgsMCwxLDAsNC43NzktNi4yNjZaTTkyOC43LDIzNS41MzNhNC45NzksNC45NzksMCwwLDAtNC4zMTcsMi41LDQuOTQ4LDQuOTQ4LDAsMCwwLDQuMjkxLDcuMzkxLDQuOTc1LDQuOTc1LDAsMCwwLDQuMzE2LTIuNSw0Ljg4Miw0Ljg4MiwwLDAsMCwuNDY0LTMuNzYxLDQuOTQsNC45NCwwLDAsMC00Ljc1NC0zLjYzWm0zNi43NzYtMTAuMzQ2YTQuOTUsNC45NSwwLDEsMCw0LjIyMiwyLjM0NUE0LjkyMyw0LjkyMywwLDAsMCw5NjUuNDc5LDIyNS4xODdabS0yMC45NTItNS40MTVhNC45NTEsNC45NTEsMCwxLDAsNC45NTEsNC45NTFBNC45NTcsNC45NTcsMCwwLDAsOTQ0LjUyNywyMTkuNzcyWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTkyMi4xNDMgLTIxOC4yKSIgZmlsbD0iIzgzMDNmZiI+PC9wYXRoPjwvc3ZnPiA=)](https://github.com/brgsil/RepoOrganizer)



  - src: cst_python source code
  - tests: code tests




  - Installing using pip:

      ```bash
      pip install --upgrade pip
      pip install cst_python
      ```

  - For installing from the repository:

      ```bash
      git clone https://github.com/H-IAAC/CST-Python
      cd CST-Python
      pip install --upgrade pip
      pip install .
      ```



  <!--Don't remove the following tags, it's used for placing the generated citation from the CFF file-->
  <!--CITATION START-->
  ```bibtext
  @software{Cardoso_do_Nascimento_CST-Python,
  author = {Cardoso do Nascimento, Elton and Dornhofer Paro Costa, Paula},
  doi = {10.5281/zenodo.14057065},
  title = {CST-Python},
  url = {https://github.com/H-IAAC/CST-Python'}
  }
  ```
  <!--CITATION END-->



  - (2023-) Elton Cardoso do Nascimento: M. Eng. student, FEEC-UNICAMP
  - (Advisor, 2023-) Paula Dornhofer Paro Costa: Professor, FEEC-UNICAMP



  Project supported by the brazilian Ministry of Science, Technology and Innovations, with resources from Law No. 8,248, of October 23, 1991



  CST-Python is a code derived from [main cst code](https://github.com/CST-Group/cst).

  ```
  Copyright 2024 H.IAAC
  Copyright 2016 CST-Group

  Licensed under the GNU LESSER GENERAL PUBLIC LICENSE, Version 3 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.gnu.org/licenses/lgpl-3.0.html

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```


pkgId: 2514c8089b0f39dc30f3df8ebc7e656481d08900db9a3ce41e7c71d7081a2996
name: python-cstag
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Python library tailored for for manipulating and visualizing minimap2's cs tags
url: https://github.com/akikuno/cstag
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cstag-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Licence](https://img.shields.io/badge/License-MIT-9cf.svg)](https://choosealicense.com/licenses/mit/)
  [![Test](https://img.shields.io/github/actions/workflow/status/akikuno/cstag/pytest.yml?branch=main&label=Test&color=brightgreen)](https://github.com/akikuno/cstag/actions)
  [![Python](https://img.shields.io/pypi/pyversions/cstag.svg?label=Python&color=blue)](https://pypi.org/project/cstag/)
  [![PyPI](https://img.shields.io/pypi/v/cstag.svg?label=PyPI&color=orange)](https://pypi.org/project/cstag/)
  [![Bioconda](https://img.shields.io/conda/v/bioconda/cstag?label=Bioconda&color=orange)](https://anaconda.org/bioconda/cstag)
  [![JOSS](https://joss.theoj.org/papers/10.21105/joss.06066/status.svg)](https://doi.org/10.21105/joss.06066)
  [![DOI](https://zenodo.org/badge/468937655.svg)](https://zenodo.org/badge/latestdoi/468937655)

   <img src="https://raw.githubusercontent.com/akikuno/logos/main/cstag/cstag-logo-microgramma.png" width="70%" alt="cstag">

  `cstag` is a Python library tailored for manipulating and visualizing [minimap2's cs tags](https://github.com/lh3/minimap2#cs).

  >[!NOTE]
  > To add cs tags to SAM/BAM files, check out [`cstag-cli`](https://github.com/akikuno/cstag-cli).



  - `cstag.call()`: Generate a cs tag
  - `cstag.shorten()`: Convert a cs tag from its long to short format
  - `cstag.lengthen()`: Convert a cs tag from its short to long format
  - `cstag.consensus()`: Create a consensus cs tag from multiple cs tags
  - `cstag.mask()`: Mask low-quality bases within a cs tag
  - `cstag.split()`: Break down a cs tag into its constituent parts
  - `cstag.revcomp()`: Convert a cs tag to its reverse complement
  - `cstag.to_sequence()`: Reconstruct a reference subsequence from the alignment
  - `cstag.to_vcf()`: Generate a VCF representation
  - `cstag.to_html()`: Generate an HTML representation

  For comprehensive documentation, please visit [our docs](https://akikuno.github.io/cstag/cstag/).




  Using [PyPI](https://pypi.org/project/cstag/):

  ```bash
  pip install cstag
  ```

  Using [Bioconda](https://anaconda.org/bioconda/cstag):

  ```bash
  conda install -c bioconda cstag
  ```





  ```python
  import cstag

  cigar = "8M2D4M2I3N1M"
  md = "2A5^AG7"
  seq = "ACGTACGTACGTACG"

  print(cstag.call(cigar, md, seq))


  print(cstag.call(cigar, md, seq, long=True))

  ```



  ```python
  import cstag


  cs_tag = "=ACGT*ag=CGT"

  print(cstag.shorten(cs_tag))




  cs_tag = ":4*ag:3"
  cigar = "8M"
  seq = "ACGTACGT"

  print(cstag.lengthen(cs_tag, cigar, seq))

  ```



  ```python
  import cstag

  cs_tags = ["=ACGT", "=AC*gt=T", "=C*gt=T", "=C*gt=T", "=ACT+ccc=T"]
  positions = [1, 1, 2, 2, 1]

  print(cstag.consensus(cs_tags, positions))

  ```



  ```python
  import cstag

  cs_tag = "=ACGT*ac+gg-cc=T"
  cigar = "5M2I2D1M"
  qual = "AA!!!!AA"
  phred_threshold = 10
  print(cstag.mask(cs_tag, cigar, qual, phred_threshold))

  ```



  ```python
  import cstag

  cs_tag = "=ACGT*ac+gg-cc=T"
  print(cstag.split(cs_tag))

  ```



  ```python
  import cstag

  cs_tag = "=ACGT*ac+gg-cc=T"
  print(cstag.revcomp(cs_tag))

  ```



  ```python
  import cstag
  cs_tag = "=AC*gt=T-gg=C+tt=A"
  print(cstag.to_sequence(cs_tag))

  ```



  ```python
  import cstag
  cs_tag = "=AC*gt=T-gg=C+tt=A"
  chrom = "chr1"
  pos = 1
  print(cstag.to_vcf(cs_tag, chrom, pos))
  """


  chr1	3	.	G	T	.	.	.
  chr1	4	.	TGG	T	.	.	.
  chr1	5	.	C	CTT	.	.	.
  """
  ```

  The multiple cs tags enable reporting of the variant allele frequency (VAF).

  ```python
  import cstag
  cs_tags = ["=ACGT", "=AC*gt=T", "=C*gt=T", "=ACGT", "=AC*gt=T"]
  chroms = ["chr1", "chr1", "chr1", "chr2", "chr2"]
  positions = [2, 2, 3, 10, 100]
  print(cstag.to_vcf(cs_tags, chroms, positions))
  """






  chr1	4	.	G	T	.	.	DP=3;RD=1;AD=2;VAF=0.667
  chr2	102	.	G	T	.	.	DP=1;RD=0;AD=1;VAF=1.0
  """
  ```



  ```python
  import cstag
  from pathlib import Path

  cs_tag = "=AC+ggg=T-acgt*at~gt10ag=GNNN"
  description = "Example"

  cs_tag_html = cstag.to_html(cs_tag, description)
  Path("report.html").write_text(cs_tag_html)

  ```

  You can visualize mutations indicated by the cs tag using the generated `report.html` file as shown below:

  <img width="511" alt="image" src="https://user-images.githubusercontent.com/15861316/265405607-a3cc1b76-f6a2-441d-b282-6f2dc06fc03d.png">




  For questions, bug reports, or other forms of feedback, we'd love to hear from you!
  Please use [GitHub Issues](https://github.com/akikuno/cstag/issues) for all reporting purposes.

  Please refer to [CONTRIBUTING](https://github.com/akikuno/cstag/blob/main/CONTRIBUTING.md) for how to contribute and how to verify your contributions.




  Please note that this project is released with a [Contributor Code of Conduct](https://github.com/akikuno/cstag/blob/main/CODE_OF_CONDUCT.md).
  By participating in this project you agree to abide by its terms.



  - Kuno, A., (2024). cstag and cstag-cli: tools for manipulating and visualizing cs tags. *Journal of Open Source Software*, 9(93), 6066, https://doi.org/10.21105/joss.06066


pkgId: 0af7b6475f5bdb88eac5816fed2f7bb9b4c770b2465661052e421121c758015e
name: python-cstruct
arch: src
version: 5.3
epoch: 0
release: 1
summary: C-style structs for Python
url: http://github.com/andreax79/python-cstruct
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cstruct-5.3-1.src.rpm
checksum_type: sha256
description:
  C-style structs for Python
  [![Build Status](https://github.com/andreax79/python-cstruct/workflows/Tests/badge.svg)](https://github.com/andreax79/python-cstruct/actions)
  [![PyPI version](https://badge.fury.io/py/cstruct.svg)](https://badge.fury.io/py/cstruct)
  [![PyPI](https://img.shields.io/pypi/pyversions/cstruct.svg)](https://pypi.org/project/cstruct)
  [![Downloads](https://pepy.tech/badge/cstruct/month)](https://pepy.tech/project/cstruct)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Known Vulnerabilities](https://snyk.io/test/github/andreax79/python-cstruct/badge.svg)](https://snyk.io/test/github/andreax79/python-cstruct)
  [![Documentation](https://readthedocs.org/projects/python-cstruct/badge/?version=latest)](https://python-cstruct.readthedocs.io/en/latest/)
  Convert C struct/union definitions into Python classes with methods for
  serializing/deserializing.
  The usage is very simple: create a class subclassing
  [`cstruct.MemCStruct`](https://python-cstruct.readthedocs.io/en/latest/api/mem_cstruct/)
  and add a C struct/union definition as a string in the `__def__` field.
  The C struct/union definition is parsed at runtime and the struct format string
  is generated. The class offers the method `unpack` for deserializing
  an array of bytes into a Python object and the method `pack` for
  serializing the values into an array of bytes.


pkgId: ba811245718f013f6cc658fd1577da07780a927e606b0d20295a9a326fd6200f
name: python-csv-converter-renyt
arch: src
version: 1.9.3
epoch: 0
release: 1
url: https://pypi.org/project/csv-converter-renyt/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv-converter-renyt-1.9.3-1.src.rpm
checksum_type: sha256
summary:
  A tool is used to convert a .csv file separatec with delimiter to a .csv file separated with Tab: "\t"


pkgId: 38546cc91fb2d4386322c71d3a00ac07302956cd1e702fb4ec2b0610beccf09c
name: python-csv-diff
arch: src
version: 1.2
epoch: 0
release: 1
summary: Python CLI tool and library for diffing CSV and JSON files
url: https://github.com/simonw/csv-diff
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv-diff-1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/csv-diff.svg)](https://pypi.org/project/csv-diff/)
  [![Changelog](https://img.shields.io/github/v/release/simonw/csv-diff?include_prereleases&label=changelog)](https://github.com/simonw/csv-diff/releases)
  [![Tests](https://github.com/simonw/csv-diff/workflows/Test/badge.svg)](https://github.com/simonw/csv-diff/actions?query=workflow%3ATest)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/csv-diff/blob/main/LICENSE)

  Tool for viewing the difference between two CSV, TSV or JSON files. See [Generating a commit log for San Francisco’s official list of trees](https://simonwillison.net/2019/Mar/13/tree-history/) (and the [sf-tree-history repo commit log](https://github.com/simonw/sf-tree-history/commits)) for background information on this project.



      pip install csv-diff



  Consider two CSV files:

  `one.csv`

      id,name,age
      1,Cleo,4
      2,Pancakes,2

  `two.csv`

      id,name,age
      1,Cleo,5
      3,Bailey,1

  `csv-diff` can show a human-readable summary of differences between the files:

      $ csv-diff one.csv two.csv --key=id
      1 row changed, 1 row added, 1 row removed

      1 row changed

        Row 1
          age: "4" => "5"

      1 row added

        id: 3
        name: Bailey
        age: 1

      1 row removed

        id: 2
        name: Pancakes
        age: 2

  The `--key=id` option means that the `id` column should be treated as the unique key, to identify which records have changed.

  The tool will automatically detect if your files are comma- or tab-separated. You can over-ride this automatic detection and force the tool to use a specific format using `--format=tsv` or `--format=csv`.

  You can also feed it JSON files, provided they are a JSON array of objects where each object has the same keys. Use `--format=json` if your input files are JSON.

  Use `--show-unchanged` to include full details of the unchanged values for rows with at least one change in the diff output:

      % csv-diff one.csv two.csv --key=id --show-unchanged
      1 row changed

        id: 1
          age: "4" => "5"

          Unchanged:
            name: "Cleo"



  You can use the `--json` option to get a machine-readable difference:

      $ csv-diff one.csv two.csv --key=id --json
      {
          "added": [
              {
                  "id": "3",
                  "name": "Bailey",
                  "age": "1"
              }
          ],
          "removed": [
              {
                  "id": "2",
                  "name": "Pancakes",
                  "age": "2"
              }
          ],
          "changed": [
              {
                  "key": "1",
                  "changes": {
                      "age": [
                          "4",
                          "5"
                      ]
                  }
              }
          ],
          "columns_added": [],
          "columns_removed": []
      }



  You can specify additional keys to be displayed in the human-readable format using the `--extra` option:

      --extra name "Python format string with {id} for variables"

  For example, to output a link to `https://news.ycombinator.com/latest?id={id}` for each item with an ID, you could use this:

  ```bash
  csv-diff one.csv two.csv --key=id \
    --extra latest "https://news.ycombinator.com/latest?id={id}"
  ```
  These extras display something like this:
  ```
  1 row changed

    id: 41459472
      points: "24" => "25"
      numComments: "5" => "6"
    extras:
      latest: https://news.ycombinator.com/latest?id=41459472
  ```



  You can also import the Python library into your own code like so:

      from csv_diff import load_csv, compare
      diff = compare(
          load_csv(open("one.csv"), key="id"),
          load_csv(open("two.csv"), key="id")
      )

  `diff` will now contain the same data structure as the output in the `--json` example above.

  If the columns in the CSV have changed, those added or removed columns will be ignored when calculating changes made to specific rows.





      $ docker build -t csvdiff .



      $ docker run --rm -v $(pwd):/files csvdiff

  Suppose current directory contains two csv files : one.csv two.csv

      $ docker run --rm -v $(pwd):/files csvdiff one.csv two.csv



  - [csvdiff](https://github.com/aswinkarthik/csvdiff) is a "fast diff tool for comparing CSV files" - you may get better results from this than from `csv-diff` against larger files.


pkgId: b46f856fab67bd548d277bab9e68cba50b2f23accdd84f1f22a5582fb55203b2
name: python-csv-ical
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Convert between CSV and iCal
url: https://github.com/albertyw/csv-ical
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv-ical-2.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/csv-ical)](https://pypi.org/project/csv-ical/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/csv-ical)
  ![PyPI - License](https://img.shields.io/pypi/l/csv-ical)

  [![Build Status](https://drone.albertyw.com/api/badges/albertyw/csv-ical/status.svg)](https://drone.albertyw.com/albertyw/csv-ical)
  [![Code Climate](https://codeclimate.com/github/albertyw/csv-ical/badges/gpa.svg)](https://codeclimate.com/github/albertyw/csv-ical)
  [![Test Coverage](https://codeclimate.com/github/albertyw/csv-ical/badges/coverage.svg)](https://codeclimate.com/github/albertyw/csv-ical/coverage)

  A simple script to convert data in CSV format to iCal format and vice
  versa.



  ```bash
  pip install csv-ical
  ```



  See the example files.



  ```bash
  pip install -e .[test]
  ruff check .
  mypy . --strict --ignore-missing-imports
  coverage run -m unittest
  coverage report -m
  ```


pkgId: b0af2ce025ddab2fff6e3a4cf4d374ce01724f6c032b79eaaf24bbe3070126e0
name: python-csv-to-dynamodb
arch: src
version: 0.2.20
epoch: 0
release: 1
url: https://pypi.org/project/csv-to-dynamodb/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv-to-dynamodb-0.2.20-1.src.rpm
checksum_type: sha256
summary:
  A library for automatically creating DynamoDB tables from CSV files and, optionally, automatically populating those tables.

description:
  A library for automatically creating DynamoDB tables from CSV files and, optionally, automatically populating those tables. The populate_table function handles floats/decimals, NaN, missing values, and create a unique Id for each row to use as a key.


pkgId: d87fb8554941bfe6b8d315ae6d632ec0b5eea1b76699050c8829a48e799d7089
name: python-csv-to-sqlite
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: A script that processes the input CSV files and copies them into a SQLite database.
url: https://github.com/zblesk/csv-to-sqlite
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv-to-sqlite-2.1.3-1.src.rpm
checksum_type: sha256
description:
  This is a simple, **datatype-guessing** script that takes CSV files as input and copies their contents into a SQLite database.
  (Column names are taken from the headers (first row) in the csv file.)
  Intended for **Python 3**. (I know it *did* run on Py2 as some people tried, but I haven't tested it.)

  * [Source on GitHub](https://github.com/zblesk/csv-to-sqlite)
  * [PyPI page](https://pypi.org/project/csv-to-sqlite/)
  * [Introductory blog post with basic intro + a how-to](http://zblesk.net/blog/csv-to-sqlite/)
  * [Other related blog posts](https://zblesk.net/blog/tag/csv-to-sqlite/)

  Installs via
  ```
   pip install csv-to-sqlite
  ```
  To find out more, run
  ```
   csv-to-sqlite --help
  ```
  If you've installed the package as a dependency for your own script, you can use it like this:
  ```python
  import csv_to_sqlite

  options = csv_to_sqlite.CsvOptions(typing_style="full", encoding="windows-1250")
  input_files = ["abilities.csv", "moves.csv"] # pass in a list of CSV files
  csv_to_sqlite.write_csv(input_files, "output.sqlite", options)
  ```


pkgId: 4fe2cfad7ba5f546864727eb0a9fbca8ba0ff75c5173af486a2f0a6ea57ebf8c
name: python-csv23
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Python 2/3 unicode CSV compatibility layer
url: https://github.com/xflr6/csv23
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv23-0.3.4-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  ``csv23`` provides the unicode-based API of the Python 3 ``csv`` module for
  Python 2 and 3. Code that should run under both versions of Python can use it
  to hide the ``bytes`` vs. ``text`` difference between 2 and 3 and stick to the
  newer unicode-based interface.
  It uses ``utf-8`` as default encoding everywhere.


pkgId: 8ab45ba1ad45841f436c20856609178e2a4bcd85d7c3468bbba84382ffdcca17
name: python-csv2geojson
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Convert csv to geojson
url: https://github.com/YuChunTsao/csv2geojson
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2geojson-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Convert csv to geojson



  ```bash
  pip install csv2geojson
  ```



  ```bash
  git clone https://github.com/YuChunTsao/csv2geojson.git

  cd csv2geojson

  pip install -e '.[test]'
  ```



  ```txt
  usage: csv2geojson [-h] [-v] [-lat lat] [-long long] [-exclude_columns [column_name ...] | -include_columns [column_name ...]]
                     input output

  Convert csv to geojson

  positional arguments:
    input                 Input csv file path
    output                Output geojson file path

  options:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
    -lat lat              Specify the latitude column in csv (default: latitude)
    -long long            Specify the longitude column in csv (default: longitude)
    -exclude_columns [column_name ...]
                          Exclude columns from geojson properties (default: None)
    -include_columns [column_name ...]
                          Include only these columns in the geojson properties (default: None)
  ```

rpm_license:
  MIT License  Copyright (c) 2022 Yu Chun Tsao  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: 83c0d47fd3c537f82f4924d55dc66a554669efddd8d59ced4fda54c3ecc6fa64
name: python-csv2ies
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Import users from a CSV file into IES
url: https://gitlab.sitepark.com/internal/csv2ies
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2ies-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Let's import users from a CSV file into an IES instance via it's REST API.



  `pip install csv2ies`



  - Needed user pools need to be created in user management beforehand.
  - Open your folder with your CSV File in the terminal.
  - Create an example config via `csv2ies config`
  - Edit the created config.json file accordingly to your needs
  - Add Aliases to match user pool names to anchors
  - Run the import: `csv2ies run`



  Known column titles are (case-insensitve):
  - "Nutzername", "Login"
  - "Vorname", "Firstname"
  - "Nachname", "Name", "Lastname"
  - "E-Mail", "Email"
  - "Geschlecht", "Anrede", "Gender"
  - "Notiz", "Note"
  - "Rolle", "roleList"
  - "Bereich", "Zones"
  - "Passwort", "Password"

  Valid roles (Rolle) are:
  - "Redakteur", "Nutzer", "User"
  - "Admin", "Administrator"
  - "Gast", "Extern", "Guest", "External"

  If a user belongs to multiple Zones (Bereiche) values need to be separated by semicolons.
  Zone names are case-sensitive!

  Gender values are mapped from first letters (csse-insensitive):
  - "h" & "m" map to male
  - "f" & "w" map to female
  - "d" & "n" map to diverse
  - everything else results in unknown gender


pkgId: bfd1634b4d1231633cc8e7faf30ce3a6267b2126084b2d81eee8fa770c17fde1
name: python-csv2md
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Command line tool for converting CSV files into Markdown tables.
description: Command line tool for converting CSV files into Markdown tables.
url: https://github.com/lzakharov/csv2md
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2md-1.3.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2023 Lev Zakharov  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: 80bc57312eb5d10092745dfe563eea90c56b052d58e445a2145870f7d6f3bc89
name: python-csv2notion
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: Import/Merge CSV files into Notion database
url: https://github.com/vzhd1701/csv2notion
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2notion-0.3.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/csv2notion?label=version)](https://pypi.python.org/pypi/csv2notion)
  [![Python Version](https://img.shields.io/pypi/pyversions/csv2notion.svg)](https://pypi.org/project/csv2notion/)
  [![tests](https://github.com/vzhd1701/csv2notion/actions/workflows/test.yml/badge.svg)](https://github.com/vzhd1701/csv2notion/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/vzhd1701/csv2notion/branch/master/graph/badge.svg)](https://codecov.io/gh/vzhd1701/csv2notion)

  An alternative way to import `*.csv` files to [Notion.so](https://notion.so).

  Due to current limitations of the official Notion SDK this tool is using the unofficial SDK by **Jamie Alexandre** [notion-py](https://github.com/jamalex/notion-py).

  Original idea belongs to [Vigneswaran Rajkumar](https://vigneswaranrajkumar.com/).



  - Actually merge CSV with existing database rows (not just add new ones), first column will be used as a key
  - Manually set column types instead of relying on autodetection
  - Automatically link or create new entries in relation columns based on their value
  - Upload files into "Files & media" column
  - Set icon for each row
  - Set cover or embed image for each row
  - Upload image file used for cover or icon
  - Options for validation of input data



  - Slower speed, since every row is imported separately
    - this is mitigated by multithreaded upload





  [**Download the latest binary release**](https://github.com/vzhd1701/csv2notion/releases/latest) for your OS.



  ```bash
  $ brew install vzhd1701/tap/csv2notion
  ```



  ```shell
  $ pipx install csv2notion
  ```



  ```bash
  $ pip install --user csv2notion
  ```

  **Python 3.7 or later required.**



  This project uses [poetry](https://python-poetry.org/) for dependency management and packaging. You will have to install it first. See [poetry official documentation](https://python-poetry.org/docs/) for instructions.

  ```shell
  $ git clone https://github.com/vzhd1701/csv2notion.git
  $ cd csv2notion/
  $ poetry install --no-dev
  $ poetry run csv2notion
  ```



  ```plain
  $ csv2notion --help
  usage: csv2notion [-h] --token TOKEN [--url URL] [OPTION]... FILE

  Import/Merge CSV file into Notion database

  positional arguments:
    FILE                               CSV file to upload

  general options:
    --token TOKEN                      Notion token, stored in token_v2 cookie for notion.so
    --url URL                          Notion database URL; if none is provided, will create a new database
    --max-threads NUMBER               upload threads (default: 5)
    --log FILE                         file to store program log
    --verbose                          output debug information
    --version                          show program's version number and exit
    -h, --help                         show this help message and exit

  column options:
    --column-types TYPES               comma-separated list of column types to use for non-key columns;
                                       if none is provided, types will be guessed from CSV values
                                       (can also be used with --add-missing-columns flag)
    --add-missing-columns              if columns are present in CSV but not in Notion DB, add them to Notion DB
    --randomize-select-colors          randomize colors for added options in select and multi select columns

  merge options:
    --merge                            merge CSV with existing Notion DB rows, first column will be used as a key
    --merge-only-column COLUMN         CSV column that should be updated on merge;
                                       when provided, other columns will be ignored
                                       (use multiple times for multiple columns)
    --merge-skip-new                   skip new rows in CSV that are not already in Notion DB during merge

  relations options:
    --add-missing-relations            add missing entries into linked Notion DB

  page cover options:
    --image-column COLUMN              CSV column that points to URL or image file that will be embedded for that row
    --image-column-keep                keep image CSV column as a Notion DB column
    --image-column-mode {cover,block}  upload image as [cover] or insert it as [block] (default: block)
    --image-caption-column COLUMN      CSV column that points to text caption that will be added to the image block
                                       if --image-column-mode is set to 'block'
    --image-caption-column-keep        keep image caption CSV column as a Notion DB column

  page icon options:
    --icon-column COLUMN               CSV column that points to emoji, URL or image file
                                       that will be used as page icon for that row
    --icon-column-keep                 keep icon CSV column as a Notion DB column
    --default-icon ICON                Emoji, URL or image file that will be used as page icon for every row by default

  validation options:
    --mandatory-column COLUMN          CSV column that cannot be empty (use multiple times for multiple columns)
    --fail-on-relation-duplicates      fail if any linked DBs in relation columns have duplicate entries;
                                       otherwise, first entry in alphabetical order
                                       will be treated as unique when looking up relations
    --fail-on-duplicates               fail if Notion DB or CSV has duplicates in key column,
                                       useful when sanitizing before merge to avoid ambiguous mapping
    --fail-on-duplicate-csv-columns    fail if CSV has duplicate columns;
                                       otherwise last column will be used
    --fail-on-conversion-error         fail if any column type conversion error occurs;
                                       otherwise errors will be replaced with empty strings
    --fail-on-inaccessible-relations   fail if any relation column points to a Notion DB that
                                       is not accessible to the current user;
                                       otherwise those columns will be ignored
    --fail-on-missing-columns          fail if columns are present in CSV but not in Notion DB;
                                       otherwise those columns will be ignored
    --fail-on-unsettable-columns       fail if DB has columns that don't support assigning value to them;
                                       otherwise those columns will be ignored
                                       (columns with type created_by, last_edited_by, rollup or formula)
    --fail-on-wrong-status-values      fail if values for 'status' columns don't have matching option in DB;
                                       otherwise those values will be replaced with default status
  ```



  You must pass a single `*.csv` file for upload. The CSV file must contain at least 2 rows. The first row will be used as a header.

  Optionally you can provide a URL to an existing Notion database with the `--url` option; if not provided, the tool will create a new database named after the CSV file. The URL must link [to a database view](https://github.com/vzhd1701/csv2notion/raw/master/examples/db_link.png), not a page.

  The tool also requires you to provide a `token_v2` cookie for the Notion website through `--token` option. For information on how to get it, see [this article](https://vzhd1701.notion.site/Find-Your-Notion-Token-5f57951434c1414d84ac72f88226eede).

  **Important notice**. `token_v2` cookie provides complete access to your Notion account. Handle it with caution.



  Due to API limitations, the upload is performed one row at a time. To speed things up, this tool uses multiple parallel threads. Use the `--max-threads` option to control how fast it will go. Try not to set it too high to avoid rate limiting by the Notion server.



  Notion does not allow the database to have multiple columns with the same name. Therefore CSV columns will be treated as unique. Only the **last** column will be used if CSV has multiple columns with the same name. If you want the program to stop if it finds duplicate columns, use the `--fail-on-duplicate-csv-columns` flag.



  If a CSV file has columns absent from Notion DB, they will be ignored by default. Use the `--add-missing-columns` flag if you want the tool to add missing columns into Notion DB. Use the `--fail-on-missing-columns` flag if you want the program to stop if it finds a column mismatch.



  By default, the tool will try to guess column types based on their content. Alternatively, you can provide a comma-separated list of column types with the `--column-types` option when creating a new database or adding new columns with the `--add-missing-columns` flag. Since the first column in Notion DB is always text, the tool will use the list to set types for the rest of the columns.

  By default, new options for `select` and `multi_select` columns are added with default (gray) color. If you want the tool to randomize colors for new options, use the `--randomize-select-colors` flag.

  Some column types do not support assigning value to them because the database generates their content automatically. Currently these types include `created_by`, `last_edited_by`, `rollup` and `formula`. If you want the program to stop if it finds such columns in the database, use the `--fail-on-unsettable-columns` flag.

  If the tool cannot convert the column value type properly, it will replace it with an empty string. If you want to make sure all values are correctly converted, use the `--fail-on-conversion-error` flag, which will stop execution in case of a conversion error.

  The table below describes available codes for `--column-types` and what values are supported by each column type:

  <details><summary>Show table</summary>
  <p>

  | Column Type<br />Name   | Column Type<br />Code   | Supported Values | Multiple Values<br />(Comma Separated) |
  | ----------------------- | ----------------------- | ---------------- | -------------------------------------- |
  | **Basic**               |                         |                  |                                        |
  | Text                    | `text`                  | string           | ❌                                     |
  | Number                  | `number`                | numerical        | ❌                                     |
  | Select                  | `select`                | string           | ❌                                     |
  | Multi-select            | `multi_select`          | string           | ✔️                                     |
  | Status                  | `status`                | string           | ❌                                     |
  | Date                    | `date`                  | any date format  | ✔️ (range)                             |
  | Person                  | `person`                | username, email  | ✔️                                     |
  | Files & media           | `file`                  | file name, URL   | ✔️                                     |
  | Checkbox                | `checkbox`              | `true`, `false`  | ❌                                     |
  | URL                     | `url`                   | string           | ❌                                     |
  | Email                   | `email`                 | string           | ❌                                     |
  | Phone                   | `phone_number`          | string           | ❌                                     |
  | **Advanced**            |                         |                  |                                        |
  | Formula                 | `formula`               | `---`            | `---`                                  |
  | Relation                | `---`                   | key, Notion URL  | ✔️                                     |
  | Rollup                  | `rollup`                | `---`            | `---`                                  |
  | Created time            | `created_time`          | any date format  | ❌                                     |
  | Created by              | `created_by`            | `---`            | `---`                                  |
  | Last edited time        | `last_edited_time`      | any date format  | ❌                                     |
  | Last edited by          | `last_edited_by`        | `---`            | `---`                                  |

  </p>
  </details>



  By default, the tool will add rows to the existing Notion DB. To merge CSV rows with the Notion database, use the `--merge` flag. The first column of CSV and Notion DB will be used as a key to update existing rows with new values. CSV rows that didn't have a match in Notion DB will be added as new.

  Since the tool treats rows as unique during merge based on the key column, it will use first found rows with a unique key. To avoid this ambiguity, you might want to validate duplicate row keys with the `--fail-on-duplicates` flag. It will check both CSV and target Notion DB before the merge.

  If you want only select columns to be updated, use the `--merge-only-column` option.

  If you don't want the tool to add any new rows not already present in the Notion DB during merge, use the `--merge-skip-new` flag.



  Notion database has a `relation` column type, which allows you to link together entries from different databases. The tool will try to match column data with keys from a linked database.

  By default, it will match with the first found row; it will add nothing if it cannot find the match. Use the `--add-missing-relations` flag if you want the tool to create new entries in the linked DB if no match is found. Use the `--fail-on-conversion-error` flag if you want the program to stop if no match is found.

  You can also use Notion URLs in columns of this type, and they must belong to the linked DB. The tool will not be able to add missing entries for URLs if you use the `--add-missing-columns` flag.

  Since the tool treats rows in the linked DB as unique you can prevent ambiguous matching with the `--fail-on-relation-duplicates` flag. It will check linked DB for duplicate keys and stop the executions if it finds any.

  If linked DB is not accessible (linked DB is deleted or your account doesn't have access to it), columns that point to it will be ignored. If you prefer the program to stop in this case, use the `--fail-on-inaccessible-relations` flag.



  The tool allows you to add an image to each row with the `--image-column` option. It will use one column from CSV as a data source for the image. It can be either a URL or a file name. The file name must be either an absolute path or a path relative to the CSV file. The tool will upload the file to the Notion server.

  By default, the tool will embed an image inside the row page. If you want it to use the image as a page cover, then set the `--image-column-mode` option to `cover`.

  Column specified with the `--image-column` option will not be treated as a regular column by default. If you want it to appear in Notion DB, use the `--image-column-keep` flag.

  To add custom caption to image block uploaded with `--image-column-mode` set to `block`, use `--image-caption-column` option. To also keep the caption as a Notion DB column, use `--image-caption-column-keep` flag.



  The tool allows you to add an icon to each row with the `--icon-column` option. The behavior is the same as with `--image-column`; the only difference is that you can use URL, file name, or single emoji.

  To also treat `--icon-column` as a regular column, use `--icon-column-keep` flag, similar to `--image-column-keep`.

  If you want to set the same icon for each row, use the `--default-icon` option. If both `--icon-column` and `--default-icon` are present, the default icon is used if the row doesn't have anything in the icon column.



  If you want to ensure that specific columns always have value and are not allowed to be empty, then use the `--mandatory-column` option. The program execution will stop if validation fails.



  - [Importing CSV into new DB](https://github.com/vzhd1701/csv2notion/raw/master/examples/new_db.png)
  - [Using custom column types](https://github.com/vzhd1701/csv2notion/raw/master/examples/new_db_types.png)
  - [Importing CSV into existing DB](https://github.com/vzhd1701/csv2notion/raw/master/examples/add_new.png)
  - [Merging CSV with existing DB](https://github.com/vzhd1701/csv2notion/raw/master/examples/merge.png)
  - [Merging CSV with select columns in existing DB](https://github.com/vzhd1701/csv2notion/raw/master/examples/merge_only.png)
  - [Importing rows with images](https://github.com/vzhd1701/csv2notion/raw/master/examples/image_column.png)
  - [Importing rows with emoji icons](https://github.com/vzhd1701/csv2notion/raw/master/examples/icon_column.png)
  - [Updating emoji icon only for all rows](https://github.com/vzhd1701/csv2notion/raw/master/examples/default_icon_only.png)



  If you found a bug or have a feature request, please [open a new issue](https://github.com/vzhd1701/csv2notion/issues/new/choose).

  If you have a question about the program or have difficulty using it, you are welcome to [the discussions page](https://github.com/vzhd1701/csv2notion/discussions). You can also mail me directly, I'm always happy to help.


pkgId: 822f1e086e0b87bf16a9d54611119da4a1bdd2c4ed7b08d4246737a7f4d0d275
name: python-csv2notion-neo
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Upload & Merge CSV or JSON Data with Images to Notion Database
url: https://github.com/TheAcharya/csv2notion-neo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2notion-neo-1.3.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/TheAcharya/csv2notion-neo"><img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/CSV2Notion Neo_Icon.png?raw=true" height="200">
    <h1 align="center">CSV2Notion Neo</h1>
  </p>


  <p align="center"><a href="https://github.com/TheAcharya/csv2notion-neo/blob/main/LICENSE"><img src="http://img.shields.io/badge/license-MIT-lightgrey.svg?style=flat" alt="license"/></a>&nbsp;<a href="https://pypi.python.org/pypi/csv2notion-neo"><img src="https://img.shields.io/pypi/v/csv2notion-neo?label=version" alt="PyPI"/></a>&nbsp;<a href="https://pypi.org/project/csv2notion-neo/"><img src="https://img.shields.io/pypi/pyversions/csv2notion-neo.svg" alt="Python"/></a>&nbsp;<a href="https://github.com/TheAcharya/csv2notion-neo/actions/workflows/release_github.yml"><img src="https://github.com/TheAcharya/csv2notion-neo/actions/workflows/release_github.yml/badge.svg" alt="release_github"/></a>&nbsp;<a href="Github All Releases"><img src="https://img.shields.io/github/downloads/TheAcharya/csv2notion-neo/total.svg" alt="release_github"/></a></p>

  An advance method to upload & merge *.csv or *.json files with images to <a href="https://notion.so/" target="_blank">Notion</a> database.





  - Merge CSV or JSON with the existing database, using the first column as a key to combine existing rows
  - Choose column types manually instead of letting Notion detecting them automatically
  - Link or create new entries in relation columns based on their values automatically
  - Easily upload files into the designated "Files & Media" column
  - Assign a icon for each row for quick identification
  - Set a cover or embed an image for each row to enhance visual representation
  - Upload image files for covers or icons
  - Apply validation options for input data to ensure accuracy
  - Automatically analyse and generate captions for images using Hugging Face's open-source AI/ML models



  - Importing each row separately might lead to slower speed
    - To address this, utilise multithreaded upload



  - [Background](#background)
  - [System Requirements](#system-requirements)
  - [Installation](#installation)
    - [Pre-compiled Binary (Recommended)](#pre-compiled-binary-recommended)
    - [From Source](#from-source)
  - [Guide](#guide)
    - [macOS Release](#macos-release)
    - [Prerequisite](#prerequisite)
    - [Upload Speed](#upload-speed)
    - [Duplicate CSV Columns](#duplicate-csv-columns)
    - [Missing Columns](#missing-columns)
    - [Column Types](#column-types)
    - [Mergin](#merging)
    - [Relation Columns](#relation-columns)
    - [Cover Image & Embedded Image](#cover-image--embedded-image)
    - [Icons](#icons)
    - [Mandatory Columns](#mandatory-columns)
    - [AI/ML Options (Hugging Face)](#aiml-options-hugging-face)
  - [Examples](#examples)
  - [Utilised By](#utilised-by)
  - [Credits](#credits)
  - [License](#license)
  - [Reporting Bugs](#reporting-bugs)



  Originally, we developed [csv2notion](https://github.com/vzhd1701/csv2notion) to address the lack of advanced importing support for `*.csv` files in [Notion](https://notion.so). We took inspiration from [Airtable](https://www.airtable.com)’s [CSV import extension](https://support.airtable.com/docs/csv-import-extension).

  **CSV2Notion Neo** was created as a spin-off project to address inactivity in the original repository and maintain compatibility with Notion. As Notion changes or updates its backend API periodically, we aim to fix, update and add new features to the tool in a timely manner. Any dependent tools or project that relied on [csv2notion](https://github.com/vzhd1701/csv2notion), can use our **CSV2Notion Neo** tool interchangeably requiring additional augments.




  - Operating System: Linux (64-bit)
  - Architecture: x64
  - Dependencies: None (ensure basic Linux shell tools are available)


  - Operating System: macOS 11 (Big Sur) or later
  - Architecture: ARM64 (Apple Silicon)
  - Dependencies: None


  - Operating System: Windows 10 or later (64-bit)
  - Architecture: x64
  - Dependencies: None





  Download the latest release of the latest binary release [here](https://github.com/TheAcharya/csv2notion-neo/releases).



  ```bash
  $ brew install TheAcharya/homebrew-tap/csv2notion-neo
  ```
  ```bash
  $ brew uninstall --cask csv2notion-neo
  ```



  ```bash
  $ pip install --user csv2notion_neo
  ```

  **Python 3.7 or later required.**



  This project uses [poetry](https://python-poetry.org/) for dependency management and packaging. You will have to install it first. See [poetry official documentation](https://python-poetry.org/docs/) for instructions.

  ```shell
  $ git clone https://github.com/TheAcharya/csv2notion-neo.git
  $ cd csv2notion_neo/
  $ poetry install --no-dev
  $ poetry run csv2notion_neo
  ```



  ```plain
  $ csv2notion_neo --help
  usage: csv2notion_neo [-h] --token TOKEN [--url URL] [OPTION]... FILE

  https://github.com/TheAcharya/csv2notion-neo

  Upload & Merge CSV or JSON Data with Images to Notion Database

  positional arguments:
    FILE                               CSV or JSON file to upload

  general options:
    --workspace                        active Notion workspace name
    --token                            Notion token, stored in token_v2 cookie for notion.so
    --url URL                          Notion database URL; if none is provided, will create a new database
    --max-threads                      upload threads (default: 5)
    --log FILE                         file to store program log
    --verbose                          output debug information
    --version                          show program's version number and exit
    -h, --help                         show this help message and exit

  machine learning options:
    --hugging-face-token              Hugging Face token to use image captioning model online
    --hf-model                        Provide the model used for generating caption <vit-gpt2 | blip-image| git-large> (defaults: vit-gpt2)
    --caption-column                  Provide both image column and column where caption would be written

  column options:
    --column-types                     comma-separated list of column types to use for non-key columns;
                                       if none is provided, types will be guessed from CSV values
                                       (can also be used with --add-missing-columns flag)
    --delimiter                        Delimiter that is used to seperate columns and rows in csv file if none is provided, ',' is taken as default
    --add-missing-columns              if columns are present in CSV but not in Notion DB, add them to Notion DB
    --rename-notion-key-column         rename the key column in the file to a different key column in Airtable
    --randomize-select-colors          randomize colors for added options in select and multi select columns

  merge options:
    --merge                            merge CSV or JSON with existing Notion DB rows, first column will be used as a key
    --merge-only-column                CSV or JSON column that should be updated on merge;
                                       when provided, other columns will be ignored
                                       (use multiple times for multiple columns)
    --merge-skip-new                   skip new rows in CSV or JSON that are not already in Notion DB during merge

  relations options:
    --add-missing-relations            add missing entries into linked Notion DB

  page cover options:
    --image-column COLUMN              one or more CSV or JSON column that points to URL or image file that will be embedded for that row
    --image-column-keep                keep image CSV or JSON column as a Notion DB column
    --image-column-mode {cover,block}  upload image as [cover] or insert it as [block] (default: block)
    --image-caption-column             CSV or JSON column that points to text caption that will be added to the image block
                                       if --image-column-mode is set to 'block'
    --image-caption-column-keep        keep image caption CSV or JSON column as a Notion DB column

  page icon options:
    --icon-column                      CSV or JSON column that points to emoji, URL or image file
                                       that will be used as page icon for that row
    --icon-column-keep                 keep icon CSV or JSON column as a Notion DB column
    --default-icon ICON                Emoji, URL or image file that will be used as page icon for every row by default

  validation options:
    --mandatory-column                 CSV or JSON column that cannot be empty (use multiple times for multiple columns)
    --payload-key-column               JSON object that is the key in Notion DB;
                                       if JSON file is used, this cannot be empty
    --fail-on-relation-duplicates      fail if any linked DBs in relation columns have duplicate entries;
                                       otherwise, first entry in alphabetical order
                                       will be treated as unique when looking up relations
    --fail-on-duplicates               fail if Notion DB or CSV or JSON has duplicates in key column,
                                       useful when sanitizing before merge to avoid ambiguous mapping
    --fail-on-duplicate-csv-columns    fail if CSV or JSON has duplicate columns;
                                       otherwise last column will be used
    --fail-on-conversion-error         fail if any column type conversion error occurs;
                                       otherwise errors will be replaced with empty strings
    --fail-on-inaccessible-relations   fail if any relation column points to a Notion DB that
                                       is not accessible to the current user;
                                       otherwise those columns will be ignored
    --fail-on-missing-columns          fail if columns are present in CSV but not in Notion DB;
                                       otherwise those columns will be ignored
    --fail-on-unsettable-columns       fail if DB has columns that don't support assigning value to them;
                                       otherwise those columns will be ignored
                                       (columns with type created_by, last_edited_by, rollup or formula)
    --fail-on-wrong-status-values      fail if values for 'status' columns don't have matching option in DB;
                                       otherwise those values will be replaced with default status
  ```



  <details><summary>Privacy & Security</summary>
  <p>

  For macOS, you have the option of two distinct releases: one packaged within a `.zip` archive and the other in a `.pkg` format. Navigate to the `Privacy & Security` settings and set your preference to `App Store and identified developers`.

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/macOS-privacy.png?raw=true"> </p>

  </p>
  </details>

  Utilise the `CSV2Notion Neo.pkg` installer to install the command-line binary into your system. Upon completion, find the installed binary `csv2notion_neo` located within `/usr/local/bin`. To uninstall, you can utalise this terminal command.

  ```plain
  sudo rm /usr/local/bin/csv2notion_neo
  ```

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/macOS-installer.png?raw=true"> </p>



  You must pass a single `*.csv` file for upload. The CSV file must contain at least 2 rows. The first row will be used as a header.

  Optionally you can provide a URL to an existing Notion database with the `--url` option; if not provided, the tool will create a new database named after the CSV file. The URL must link to a database view, not a page.

  <details><summary>Obtaining Database URL</summary>
  <p>

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/database_url.png?raw=true"> </p>

  </p>
  </details>

  <details><summary>Obtaining Workspace Name</summary>
  <p>

  <p align="center"> <img src="https://www.notion.so/cdn-cgi/image/format=auto,width=3840,quality=100/https://images.ctfassets.net/spoqsaf9291f/36DSq2EcSv3Q9uUUnRXdMo/9f8e7900ef53569a84c8625097bcc271/Workspace_settings_-_hero.png"> </p>

  1. To see your Workspace name go to `Settings & members` at the top of the left sidebar. In the window that pops up, click on the `Settings` tab.
  2. If your Workspace name is `Acme Inc.`, you are required to provide `--workspace "Acme Inc."` as such.

  </p>
  </details>


  The tool also requires you to provide a `token_v2` cookie for the Notion website through `--token` option.

  1. Login to your [Notion](https://www.notion.so/login) account via a web browser.
  2. Find and copy the entire `token_v2` value including `v02%3Auser_token_or_cookies%` from your Notion session.

  <details><summary>Obtaining Notion Session Token (Safari)</summary>
  <p>

  Enable Web Inspector

  - If you don’t see the Develop menu in the menu bar, choose Safari, Settings, click Advanced, then select “Show features for web developers”.
  - Press `⌥ + ⌘ + i` to show Web Inspector

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/notion_token_safari.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Obtaining Notion Session Token (Brave, Chrome or Edge)</summary>
  <p>

  - Press ⌥ + ⌘ + i (Mac) or  Shift + Crtl + i (Win) to show Developer Tools.
  - Go to Application tab.
  - Copy and obtain your token_v2 value.

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/notion_token_brave.png?raw=true"> </p>

  </p>
  </details>

  **Important notice**. `token_v2` cookie provides complete access to your Notion account. Handle it with caution.



  Due to API limitations, the upload is performed one row at a time. To speed things up, this tool uses multiple parallel threads. Use the `--max-threads` option to control how fast it will go. Try not to set it too high to avoid rate limiting by the Notion server.



  Notion does not allow the database to have multiple columns with the same name. Therefore CSV columns will be treated as unique. Only the **last** column will be used if CSV has multiple columns with the same name. If you want the program to stop if it finds duplicate columns, use the `--fail-on-duplicate-csv-columns` flag.



  If a CSV file has columns absent from Notion DB, they will be ignored by default. Use the `--add-missing-columns` flag if you want the tool to add missing columns into Notion DB. Use the `--fail-on-missing-columns` flag if you want the program to stop if it finds a column mismatch.



  By default, the tool will try to guess column types based on their content. Alternatively, you can provide a comma-separated list of column types with the `--column-types` option when creating a new database or adding new columns with the `--add-missing-columns` flag. Since the first column in Notion DB is always text, the tool will use the list to set types for the rest of the columns.

  By default, new options for `select` and `multi_select` columns are added with default (gray) color. If you want the tool to randomize colors for new options, use the `--randomize-select-colors` flag.

  Some column types do not support assigning value to them because the database generates their content automatically. Currently these types include `created_by`, `last_edited_by`, `rollup` and `formula`. If you want the program to stop if it finds such columns in the database, use the `--fail-on-unsettable-columns` flag.

  If the tool cannot convert the column value type properly, it will replace it with an empty string. If you want to make sure all values are correctly converted, use the `--fail-on-conversion-error` flag, which will stop execution in case of a conversion error.

  The table below describes available codes for `--column-types` and what values are supported by each column type:

  <details><summary>Support Table</summary>
  <p>

  | Column Type<br />Name   | Column Type<br />Code   | Supported Values | Multiple Values<br />(Comma Separated) |
  | ----------------------- | ----------------------- | ---------------- | -------------------------------------- |
  | **Basic**               |                         |                  |                                        |
  | Text                    | `text`                  | string           | ❌                                     |
  | Number                  | `number`                | numerical        | ❌                                     |
  | Select                  | `select`                | string           | ❌                                     |
  | Multi-select            | `multi_select`          | string           | ✅                                     |
  | Status                  | `status`                | string           | ❌                                     |
  | Date                    | `date`                  | any date format  | ✅ (range)                             |
  | Person                  | `person`                | username, email  | ✅                                     |
  | Files & media           | `file`                  | file name, URL   | ✅                                     |
  | Checkbox                | `checkbox`              | `true`, `false`  | ❌                                     |
  | URL                     | `url`                   | string           | ❌                                     |
  | Email                   | `email`                 | string           | ❌                                     |
  | Phone                   | `phone_number`          | string           | ❌                                     |
  | **Advanced**            |                         |                  |                                        |
  | Formula                 | `formula`               | `---`            | `---`                                  |
  | Relation                | `---`                   | key, Notion URL  | ✅                                     |
  | Rollup                  | `rollup`                | `---`            | `---`                                  |
  | Created time            | `created_time`          | any date format  | ❌                                     |
  | Created by              | `created_by`            | `---`            | `---`                                  |
  | Last edited time        | `last_edited_time`      | any date format  | ❌                                     |
  | Last edited by          | `last_edited_by`        | `---`            | `---`                                  |

  </p>
  </details>



  By default, the tool will add rows to the existing Notion DB. To merge CSV rows with the Notion database, use the `--merge` flag. The first column of CSV and Notion DB will be used as a key to update existing rows with new values. CSV rows that didn't have a match in Notion DB will be added as new.

  Since the tool treats rows as unique during merge based on the key column, it will use first found rows with a unique key. To avoid this ambiguity, you might want to validate duplicate row keys with the `--fail-on-duplicates` flag. It will check both CSV and target Notion DB before the merge.

  If you want only select columns to be updated, use the `--merge-only-column` option.

  If you don't want the tool to add any new rows not already present in the Notion DB during merge, use the `--merge-skip-new` flag.



  Notion database has a `relation` column type, which allows you to link together entries from different databases. The tool will try to match column data with keys from a linked database.

  By default, it will match with the first found row; it will add nothing if it cannot find the match. Use the `--add-missing-relations` flag if you want the tool to create new entries in the linked DB if no match is found. Use the `--fail-on-conversion-error` flag if you want the program to stop if no match is found.

  You can also use Notion URLs in columns of this type, and they must belong to the linked DB. The tool will not be able to add missing entries for URLs if you use the `--add-missing-columns` flag.

  Since the tool treats rows in the linked DB as unique you can prevent ambiguous matching with the `--fail-on-relation-duplicates` flag. It will check linked DB for duplicate keys and stop the executions if it finds any.

  If linked DB is not accessible (linked DB is deleted or your account doesn't have access to it), columns that point to it will be ignored. If you prefer the program to stop in this case, use the `--fail-on-inaccessible-relations` flag.



  The tool allows you to add an image to each row with the `--image-column` option. It will use one column from CSV as a data source for the image. It can be either a URL or a file name. The file name must be either an absolute path or a path relative to the CSV file. The tool will upload the file to the Notion server.

  By default, the tool will embed an image inside the row page. If you want it to use the image as a page cover, then set the `--image-column-mode` option to `cover`.

  Column specified with the `--image-column` option will not be treated as a regular column by default. If you want it to appear in Notion DB, use the `--image-column-keep` flag.

  To add custom caption to image block uploaded with `--image-column-mode` set to `block`, use `--image-caption-column` option. To also keep the caption as a Notion DB column, use `--image-caption-column-keep` flag.



  The tool allows you to add an icon to each row with the `--icon-column` option. The behavior is the same as with `--image-column`; the only difference is that you can use URL, file name, or single emoji.

  To also treat `--icon-column` as a regular column, use `--icon-column-keep` flag, similar to `--image-column-keep`.

  If you want to set the same icon for each row, use the `--default-icon` option. If both `--icon-column` and `--default-icon` are present, the default icon is used if the row doesn't have anything in the icon column.



  If you want to ensure that specific columns always have value and are not allowed to be empty, then use the `--mandatory-column` option. The program execution will stop if validation fails.



  Hugging Face is a prominent AI company known for its contributions to natural language processing (NLP) through its comprehensive open-source platform. It offers an extensive library called Transformers, which provides pre-trained models for a wide range of NLP tasks, including text generation, sentiment analysis, translation, and more. These models are based on state-of-the-art architectures like BERT, GPT, and T5.

  The platform fosters a vibrant open-source community where developers and researchers can share and collaborate on models. Users can access, fine-tune, and deploy a vast array of community-contributed models via the Hugging Face Model Hub. This collaborative environment accelerates innovation and democratizes access to advanced machine learning tools.

  <details><summary>Obtaining Hugging Face Token</summary>
  <p>

  Steps to Obtain a Hugging Face Token with Write Mode

  1. **Create a Hugging Face Account (if you don't have one already):**
     - Go to the [Hugging Face website](https://huggingface.co/).
     - Click on "Sign Up" in the top right corner.
     - Fill in your details (username, email, password) and complete the registration process.

  2. **Log In to Your Account:**
     - If you already have an account, simply log in by clicking "Log In" and entering your credentials.

  3. **Navigate to Your Profile Settings:**
     - Once logged in, click on your profile icon in the top right corner of the page.
     - From the dropdown menu, select "Settings."

  4. **Access the API Tokens Section:**
     - In the settings menu on the left side of the screen, find and click on "Access Tokens."

  5. **Create a New API Token:**
     - In the "Access Tokens" section, you will see an option to create a new token.
     - Click on "New token."

  6. **Set Permissions to Write Mode:**
     - Provide a name for your token (e.g., "MyWriteToken").
     - Set the permissions type to "Write" type by selecting the "Write" from the dropdown. This will grant the token write access, allowing you to perform actions that modify data on Hugging Face.

  7. **Generate and Copy Your Token:**
     - Click on the "Generate token" button.
     - Your new token will be displayed. Copy it and store it in a secure place, as you will need it to access Hugging Face's API services.

  **Note:** Keep your token secure and do not share it publicly, as it grants access to your Hugging Face account and its resources.

  </p>
  </details>

  <details><summary>Avaliable Model Information</summary>
  <p>

  | Models      | Information                                                          | Accuracy |
  | ---------- | -------------------------------------------------------------------- | -------- |
  | vit-gpt2   | [Link](https://huggingface.co/nlpconnect/vit-gpt2-image-captioning)  | Low - Medium   |
  | blip-image | [Link](https://huggingface.co/Salesforce/blip-image-captioning-base) | Low - Medium   |
  | git-large  | [Link](https://huggingface.co/microsoft/git-large)                   | Low - Medium   |

  **Note:** Additional models will be integrated in the future from Hugging Face as better models are identified.

  </p>
  </details>

  > [!WARNING]
  > Please be aware that this feature is currently in an experimental phase. We strongly advise against uploading sensitive images or those of a personal and private nature. Images will be uploaded to Hugging Face’s servers for analysis. We recommend using commercial images, such as movie stills or stock photos, for AI captioning.



  <details><summary>Importing CSV into New Database</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_01.png?raw=true"> </p>

  </p>
  </details>

  <details><summary>Using Custom Column Types</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --column-types "number,multi_select" test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_02.png?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing CSV into Existing Database</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --url NOTION_URL test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_03.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Merging CSV with Existing Database</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --url NOTION_URL \
    --merge test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_04.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Merging CSV with Select Columns in Existing Database</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_ TOKEN_HERE \
    --url NOTION URL \
    --merge \
    --merge-only-column "Column 2" \
    --merge-onLy-column "Column 3" test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_05.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing Rows with Images</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
  --image-column "Image Column" test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_06.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing Rows with Images (Multiple Image Column)</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --image-column "Colour Image" "Black & White Image" "Map" \
    --image-column-keep --mandatory-column "Cat ID" test.csv
  ```

  Example CSV

  ```text
  Cat ID,Animal Name,Location,Colour Image,Black & White Image,Map
  1,Lion,Namibia,Colour/lion.jpg,Black & White/lion.jpg,Map/Namibia.jpg
  2,Tiger,India,Colour/tiger.jpg,Black & White/tiger.jpg,Map/India.jpg
  3,Panther,India,Colour/panther.jpg,Black & White/panther.jpg,Map/India.jpg
  4,Snow Leopard,Nepal,Colour/snow_leopard.jpg,Black & White/snow_leopard.jpg,Map/Nepal.jpg
  5,Cheetah,South Africa,Colour/cheetah.jpg,Black & White/cheetah.jpg,Map/South Africa.jpg
  6,Puma,South America,Colour/puma.jpg,Black & White/puma.jpg,Map/South America.jpg
  7,Jaguar,Brazil,Colour/jaguar.jpg,Black & White/jaguar.jpg,Map/Brazil.jpg
  ```

  Example Folder Structure

  ```text
  ├─ Data/
  │  ├─ test.csv
  │  ├─ Black & White/
  │  │  ├─ cheetah.jpg
  │  │  ├─ jaguar.jpg
  │  │  ├─ lion.jpg
  │  │  ├─ panther.jpg
  │  │  ├─ puma.jpg
  │  │  ├─ snow_leopard.jpg
  │  │  ├─ tiger.jpg
  │  ├─ Colour/
  │  │  ├─ cheetah.jpg
  │  │  ├─ jaguar.jpg
  │  │  ├─ lion.jpg
  │  │  ├─ panther.jpg
  │  │  ├─ puma.jpg
  │  │  ├─ snow_leopard.jpg
  │  │  ├─ tiger.jpg
  │  ├─ Map/
  │  │  ├─ Brazil.jpg
  │  │  ├─ India.jpg
  │  │  ├─ Namibia.jpg
  │  │  ├─ Nepal.jpg
  │  │  ├─ South Africa.jpg
  │  │  ├─ South America.jpg
  │  │  ├─ tiger.jpg
  ```

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_11.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing Rows with Emoji Icons</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE  \
    --icon-column "Icon Column" test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_07.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Updating Emoji Icon Only for All Rows</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --url NOTION_URL \
    --default-icon 👍 \
    --merge \
    --merge-only-column "Key" test.csv
  ```
  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_08.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing JSON into Existing Database</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --url NOTION_URL \
    --mandatory-column "Cat ID" \
    --payload-key-column "Cat ID" \
    --merge JSON-Demo.json
  ```

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_09.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Importing JSON into Existing Database with a Different Key Column</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE \
    --url NOTION_URL \
    --mandatory-column "Cat ID" \
    --payload-key-column "Cat ID" \
    --rename-notion-key-column "Cat ID" "Anything ID" \
    --merge JSON-Demo.json
  ```

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_10.gif?raw=true"> </p>

  </p>
  </details>

  <details><summary>Utilising Hugging Face's AI/ML Model to Automatically Analyse and Generate Captions from Images</summary>
  <p>

  ```shell
  csv2notion_neo --workspace YOUR_WORKSPACE_NAME_HERE --token YOUR_TOKEN_HERE --url NOTION_URL --hugging-face-token YOUR_HUGGING_FACE_TOKEN_HERE \
    --hf-model blip-image \
    --caption-column "Image Filename" "Frame Description" \
    --image-column "Image Filename" \
    --image-column-keep \
    --mandatory-column "Cat ID" \
    --merge big_cats.csv
  ```

  <p align="center"> <img src="https://github.com/TheAcharya/csv2notion-neo/blob/master/assets/example_12.gif?raw=true"> </p>

  </p>
  </details>





  <details><summary>Marker Data's Notion Panel</summary>
  <p>

  <p align="center"> <img src="https://github.com/TheAcharya/MarkerData-Website/blob/main/docs/assets/md-database-settings_01.png?raw=true"> </p>

  </p>
  </details>



  <details><summary>CommandPost's Notion Toolbox</summary>
  <p>

  <p align="center"> <img src="https://github.com/CommandPost/CommandPost-Website/blob/main/docs/static/toolbox-notion.png?raw=true"> </p>

  </p>
  </details>



  Original Idea and Workflow Architecture by [Vigneswaran Rajkumar](https://twitter.com/IAmVigneswaran)

  Maintained by [Arjun Prakash](https://github.com/arjunprakash027) (1.0.0 ...)

  Original Work by [Vladilen Zhdanov](https://github.com/vzhd1701)

  Icon Design by [Bor Jen Goh](https://www.artstation.com/borjengoh)



  Licensed under the MIT license. See [LICENSE](https://github.com/TheAcharya/csv2notion-neo/blob/master/LICENSE) for details.



  For bug reports, feature requests and other suggestions you can create [a new issue](https://github.com/TheAcharya/csv2notion-neo/issues) to discuss.


pkgId: 721180902471577e1afbb11cecd3900c32b36bd833e7954ef14ed2255ef87e34
name: python-csv2parquet
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A tool to convert CSVs to Parquet files
url: https://github.com/cldellow/csv2parquet
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2parquet-0.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/cldellow/csv2parquet.svg?branch=master)](https://travis-ci.org/cldellow/csv2parquet)
  [![codecov](https://codecov.io/gh/cldellow/csv2parquet/branch/master/graph/badge.svg)](https://codecov.io/gh/cldellow/csv2parquet)

  Convert a CSV to a parquet file. You may also find [sqlite-parquet-vtable](https://github.com/cldellow/sqlite-parquet-vtable) or
  [parquet-metadata](https://github.com/cldellow/parquet-metadata) useful.



  If you just want to use the tool:

  ```
  sudo pip install pyarrow csv2parquet
  ```

  If you want to clone the repo and work on the tool, install its dependencies via pipenv:

  ```
  pipenv install
  ```



  Next, create some Parquet files. The tool supports CSV and TSV files.

  ```
  usage: csv2parquet [-h] [-n ROWS] [-r ROW_GROUP_SIZE] [-o OUTPUT] [-c CODEC]
                     [-i INCLUDE [INCLUDE ...] | -x EXCLUDE [EXCLUDE ...]]
                     [-R RENAME [RENAME ...]] [-t TYPE [TYPE ...]]
                     csv_file

  positional arguments:
    csv_file              input file, can be CSV or TSV

  optional arguments:
    -h, --help            show this help message and exit
    -n ROWS, --rows ROWS  The number of rows to include, useful for testing.
    -r ROW_GROUP_SIZE, --row-group-size ROW_GROUP_SIZE
                          The number of rows per row group.
    -o OUTPUT, --output OUTPUT
                          The parquet file
    -c CODEC, --codec CODEC
                          The compression codec to use (brotli, gzip, snappy,
                          zstd, none)
    -i INCLUDE [INCLUDE ...], --include INCLUDE [INCLUDE ...]
                          Include the given columns (by index or name)
    -x EXCLUDE [EXCLUDE ...], --exclude EXCLUDE [EXCLUDE ...]
                          Exclude the given columns (by index or name)
    -R RENAME [RENAME ...], --rename RENAME [RENAME ...]
                          Rename a column. Specify the column to be renamed and
                          its new name, eg: 0=age or person_age=age
    -t TYPE [TYPE ...], --type TYPE [TYPE ...]
                          Parse a column as a given type. Specify the column and
                          its type, eg: 0=bool? or person_age=int8. Parse errors
                          are fatal unless the type is followed by a question
                          mark. Valid types are string (default), base64, bool,
                          float32, float64, int8, int16, int32, int64, timestamp
  ```



  ```
  pylint csv2parquet
  pytest
  ```


pkgId: 57338877150a7ed48b28b303cc9cceb4292840a26aaf6a3df512723e438823fd
name: python-csv2pdf
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Easily convert CSV Files to PDF Files using Python!
url: https://github.com/TECH-SAVVY-GUY/csv2pdf
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2pdf-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ![](https://raw.githubusercontent.com/TECH-SAVVY-GUY/csv2pdf/master/convert.png)



  ```python
  pip install csv2pdf
  ```




  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf")
  ```

  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", orientation="L")
  ```

  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", delimiter="&")
  ```

  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", align="L")

  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", align="R")
  ```

  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", size=5)

  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf", headersize=7)
  ```

  ```python


  >>> from csv2pdf import convert
  >>> convert("source.csv", "destination.pdf",
              font=r"Fonts\custom-font.tff", headerfont=r"Fonts\custom-header-font.tff")
  ```

  ***Use*** `.tff` ***files for specifying font files. Fonts can be downloaded from **[Google Fonts](https://fonts.google.com/)**.***


pkgId: 70591fa30e7cf7f95a1b7171eaf529981732d68671850813ed238e8e22026c81
name: python-csv2sendy
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: A CSV processor for Sendy.co with Brazilian data format support
url: https://github.com/skaisser/csv2sendy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv2sendy-1.0.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  [![PyPI version](https://badge.fury.io/py/csv2sendy.svg)](https://badge.fury.io/py/csv2sendy)
  [![Python Version](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390/)
  [![Tests](https://github.com/skaisser/csv2sendy/actions/workflows/tests.yml/badge.svg)](https://github.com/skaisser/csv2sendy/actions/workflows/tests.yml)
  [![Coverage Status](https://coveralls.io/repos/github/skaisser/csv2sendy/badge.svg?branch=main)](https://coveralls.io/github/skaisser/csv2sendy?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/csv2sendy/badge/?version=latest)](https://csv2sendy.readthedocs.io/en/latest/?badge=latest)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code Style: Mypy](https://img.shields.io/badge/type%20checked-mypy-blue.svg)](http://mypy-lang.org/)

  A powerful CSV processor for Sendy.co with Brazilian data format support.

  [Documentation](https://csv2sendy.readthedocs.io) |
  [GitHub Repository](https://github.com/skaisser/csv2sendy)

  </div>



  - 🔄 **Intelligent CSV Processing**
    - Auto-detection of delimiters (`,` or `;`)
    - Multiple encoding support (utf-8-sig, latin1, iso-8859-1, cp1252)
    - Smart column mapping and normalization
    - Robust error handling

  - 📧 **Email Validation**
    - RFC-compliant email validation
    - Case normalization
    - Duplicate removal
    - Invalid email filtering

  - 📱 **Phone Number Processing**
    - Brazilian format support
    - Format standardization
    - Invalid number filtering
    - DDD (area code) validation

  - 👤 **Name Processing**
    - First/last name splitting
    - Proper capitalization
    - Special character handling
    - Empty name filtering

  - 🌐 **Web Interface**
    - File upload and processing
    - Column mapping
    - Tag management
    - CSV download

  - 🔒 **Security**
    - Secure file handling
    - Automatic file cleanup
    - Input sanitization
    - File size limits





  ```bash
  pip install csv2sendy
  ```



  ```bash
  git clone https://github.com/skaisser/csv2sendy.git
  cd csv2sendy
  pip install -e ".[dev]"
  ```





  ```bash

  python -m csv2sendy.web.app
  ```

  Visit http://localhost:8080 in your browser.



  ```bash

  csv2sendy


  csv2sendy 3000


  csv2sendy --help
  ```

  The CLI provides a convenient way to start the web interface. By default, it starts the server on port 8080, but you can specify a different port as a command-line argument.



  ```python
  from csv2sendy.core import CSVProcessor


  processor = CSVProcessor()
  df = processor.process_file('input.csv')
  df.to_csv('output.csv', index=False)


  content = '''name,email,phone
  John Doe,john@example.com,(11) 98765-4321'''
  df = processor.process_file(content)
  ```





  1. Clone the repository:
  ```bash
  git clone https://github.com/skaisser/csv2sendy.git
  cd csv2sendy
  ```

  2. Create a virtual environment:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  ```

  3. Install development dependencies:
  ```bash
  pip install -e ".[dev,test,doc]"
  ```



  Run tests with coverage:
  ```bash
  pytest --cov=csv2sendy tests/
  ```

  Run type checking:
  ```bash
  mypy csv2sendy
  ```



  Build documentation:
  ```bash
  cd docs
  make html
  ```



  - Python 3.9
  - pandas >= 1.3.0
  - email-validator >= 1.1.0
  - flask >= 2.0.0
  - werkzeug >= 2.0.0



  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/amazing-feature`)
  3. Install development dependencies (`pip install -e ".[dev,test,doc]"`)
  4. Make your changes
  5. Run tests and type checking (`pytest` and `mypy csv2sendy`)
  6. Commit your changes (`git commit -m 'Add amazing feature'`)
  7. Push to the branch (`git push origin feature/amazing-feature`)
  8. Open a Pull Request



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.



  **Shirleyson Kaisser**

  - GitHub: [@skaisser](https://github.com/skaisser)
  - Email: skaisser@gmail.com


pkgId: 92413d0c55f799422f1fd097a8f5a179a3b062bd502be40f833de97ea4b6a930
name: python-csv342
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python 3 like CSV module for Python 2
url: http://pypi.python.org/pypi/csv342/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csv342-1.0.1-1.src.rpm
checksum_type: sha256
description:
  csv342 is a Python module similar to the the csv module in the standard
  library. Under Python 3, it just calls the standard csv module. Under
  Python 2, it provides a Python 3 like interface to reading and writing CSV
  files, in particular concerning non ASCII characters.
  It is distributed under the BSD license. The source code is available from
  https://github.com/roskakori/csv342.


pkgId: a00d6d4a7ba3783fed42c1692752740e5ec44eb254ba572f504f6b0b2c137575
name: python-csvdedupe
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: Command line tools for deduplicating and merging csv files
url: https://pypi.org/project/csvdedupe/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvdedupe-0.1.20-1.src.rpm
checksum_type: sha256
description:
  `csvlink` takes two CSV files and finds matches between them.
  Provide an input file, field names, and output file:
  ```bash
  csvlink examples/restaurant-1.csv examples/restaurant-2.csv \
              --field_names name address city cuisine \
              --output_file output.csv
  ```
  __or__
  Line up different field names from each file:
  ```bash
  csvlink examples/restaurant-1.csv examples/restaurant-2.csv \
              --field_names_1 name address city cuisine \
              --field_names_2 restaurant street city type \
              --output_file output.csv
  ```
  __or__
  Pipe the output to STDOUT:
  ```bash
  csvlink examples/restaurant-1.csv examples/restaurant-2.csv \
              --field_names name address city cuisine \
              > output.csv
  ```
  __or__
  Define everything in a config file:
  ```bash
  csvlink examples/restaurant-1.csv examples/restaurant-2.csv \
                --config_file=config.json
  ```
  **Your config file may look like this:**
  ```json
  {
    "field_names_1": ["name", "address", "city", "cuisine"],
    "field_names_2": ["restaurant", "street", "city", "type"],
    "field_definition" : [{"field" : "name", "type" : "String"},
                          {"field" : "address", "type" : "String"},
                          {"field" : "city", "type" : "String",
                           "Has Missing" : true},
                          {"field" : "cuisine", "type" : "String",
                           "Has Missing" : true}],
    "output_file": "examples/output.csv",
    "skip_training": false,
    "training_file": "training.json",
    "sample_size": 150000,
    "recall_weight": 2
  }
  ```

    * `input` two CSV file names to join together
  Either
    * `--config_file` Path to configuration file.
  Or
    * `--field_names_1` List of column names in first file for dedupe to pay attention to
    * `--field_names_2` List of column names in second file for dedupe to pay attention to

    * `--output_file OUTPUT_FILE`
                          CSV file to store deduplication results (default:
                          None)
    * `--inner_join`          Only return matches between datasets
    * `--skip_training`       Skip labeling examples by user and read training from
                          training_file only (default: False)
    * `--training_file TRAINING_FILE`
                          Path to a new or existing file consisting of labeled
                          training examples (default: training.json)
    * `--sample_size SAMPLE_SIZE`
                          Number of random sample pairs to train off of
                          (default: 150000)
    * `--recall_weight RECALL_WEIGHT`
                          Threshold that will maximize a weighted average of our
                          precision and recall (default: 2)
    * `-d`, `--delimiter`
                          Delimiting character of the input CSV file (default: ,)
    * `-h`, `--help`            show help message and exit

  The _secret sauce_ of csvdedupe is human input. In order to figure out the best rules to deduplicate a set of data, you must give it a set of labeled examples to learn from.
  The more labeled examples you give it, the better the deduplication results will be. At minimum, you should try to provide __10 positive matches__ and __10 negative matches__.
  The results of your training will be saved in a JSON file ( __training.json__, unless specified otherwise with the `--training-file` option) for future runs of csvdedupe.
  Here's an example labeling operation:
  ```bash
  Phone :  2850617
  Address :  3801 s. wabash
  Zip :
  Site name :  ada s. mckinley st. thomas cdc
  Phone :  2850617
  Address :  3801 s wabash ave
  Zip :
  Site name :  ada s. mckinley community services - mckinley - st. thomas
  Do these records refer to the same thing?
  (y)es / (n)o / (u)nsure / (f)inished
  ```

  `csvdedupe` attempts to identify all the rows in the csv that refer to the same thing. Each group of
  such records are called a cluster. `csvdedupe` returns your input file with an additional column called `Cluster ID`,
  that either is the numeric id (zero-indexed) of a cluster of grouped records or an `x` if csvdedupe believes
  the record doesn't belong to any cluster.
  `csvlink` operates in much the same way as `csvdedupe`, but will flatten both CSVs in to one
  output file similar to a SQL [OUTER JOIN](http://stackoverflow.com/questions/38549/difference-between-inner-and-outer-join) statement. You can use the `--inner_join` flag to exclude rows that don't match across the two input files, much like an INNER JOIN.

  csvdedupe attempts to convert all strings to ASCII, ignores case, new lines, and padding whitespace. This is all
  probably uncontroversial except the conversion to ASCII. Basically, we had to choose between two ways of handling
  extended characters.
  ```
  distance("Tomas", "Tomás')  = distance("Tomas", "Tomas")
  ```
  __or__
  ```
  distance("Tomas, "Tomás") = distance("Tomas", "Tomzs")
  ```
  We chose the first option. While it is possible to do something more sophisticated, this option seems to work pretty well
  for Latin alphabet languages.

  Unit tests of core csvdedupe functions
  ```bash
  pip install -r requirements-test.txt
  nosetests
  ```

  * [Dedupe Google group](https://groups.google.com/forum/?fromgroups=#!forum/open-source-deduplication)
  * IRC channel, #dedupe on irc.freenode.net


  Lets say we have a few sources of early childhood programs in Chicago and we'd like to get a canonical list.
  Let's do it with `csvdedupe`, `csvkit`, and some other common command line tools.

  Our first task will be to align the files and have the same data in the same columns for stacking.
  First, let's look at the headers of the files.
  File 1
  ```console
  > head -1 CPS_Early_Childhood_Portal_Scrape.csv
  "Site name","Address","Phone","Program Name","Length of Day"
  ```
  File 2
  ```console
  > head -1 IDHS_child_care_provider_list.csv
  "Site name","Address","Zip Code","Phone","Fax","IDHS Provider ID"
  ```
  So, we'll have to add "Zip Code", "Fax", and "IDHS Provider ID"
  to ```CPS_Early_Childhood_Portal_Scrape.csv```, and we'll have to add "Program Name",
  "Length of Day" to ```IDHS_child_care_provider_list.csv```.
  ```console
  > cd examples
  > sed '1 s/$/,"Zip Code","Fax","IDHS Provider ID"/' CPS_Early_Childhood_Portal_Scrape.csv > input_1a.csv
  > sed '2,$s/$/,,,/' input_1a.csv > input_1b.csv
  ```
  ```console
  > sed '1 s/$/,"Program Name","Length of Day"/' IDHS_child_care_provider_list.csv > input_2a.csv
  > sed '2,$s/$/,,/' input_2a.csv > input_2b.csv
  ```
  Now, we reorder the columns in the second file to align to the first.
  ```console
  > csvcut -c "Site name","Address","Phone","Program Name","Length of Day","Zip Code","Fax","IDHS Provider ID" \
           input_2b.csv > input_2c.csv
  ```
  And we are finally ready to stack.
  ```console
  > csvstack -g CPS_Early_Childhood_Portal_Scrape.csv,IDHS_child_care_provider_list.csv \
             -n source \
             input_1b.csv input_2c.csv > input.csv
  ```

  And now we can dedupe
  ```console
  > cat input.csv | csvdedupe --field_names "Site name" Address "Zip Code" Phone > output.csv
  ```
  Let's sort the output by duplicate IDs, and we are ready to open it in your favorite spreadsheet program.
  ```console
  > csvsort -c "Cluster ID" output.csv > sorted.csv
  ```

  If something is not behaving intuitively, it is a bug, and should be reported.
  Report it [here](https://github.com/dedupeio/csvdedupe/issues).

  We welcome your ideas! You can make suggestions in the form of [github issues](https://github.com/dedupeio/csvdedupe/issues) (bug reports, feature requests, general questions), or you can submit a code contribution via a pull request.
  How to contribute code:
  - Fork the project.
  - Make your feature addition or bug fix.
  - Send us a pull request with a description of your work! Don't worry if it isn't perfect - think of a PR as a start of a conversation, rather than a finished product.

  Copyright (c) 2016 DataMade. Released under the [MIT License](https://github.com/dedupeio/csvdedupe/blob/master/LICENSE.md).


pkgId: 16030aec0e5f9a38114f69ad05eded228c904e6d802d35e5189a43d90bb72144
name: python-csvfile
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: A simple way of working with csv files.
url: https://github.com/imbolc/csvfile
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvfile-3.4.0-1.src.rpm
checksum_type: sha256
description:
  A simple way of working with csv files.
  You can use:
  ```python
  data = csvfile.load("my-data.csv")
  data[0].field = "new value"
  data.sync()
  ```
  Instead of:
  ```python
  data = []
  with open("my-data.csv") as f:
      reader = csv.DictReader(f)
      fieldnames = reader.fieldnames
      for row in reader:
          data.append(row)
  data[0]["field"] = "new value"
  with open("my-data.csv, "w") as f:
      writer = csv.DictWriter(f, fieldnames=fieldnames)
      writer.writeheader()
      writer.writerows(data)
  ```
  Also you can declaratively define types in a table's header:
  ```python
  >>> print(open("/tmp/csvfile_test.csv").read())
  language,created:i
  python,1991
  js,1995
  rust,2010
  >>> pprint(csvfile.load("/tmp/csvfile_test.csv"))
  [{'created': 1991, 'language': 'python'},
   {'created': 1995, 'language': 'js'},
   {'created': 2010, 'language': 'rust'}]
  ```
  Notice, that `created` is automatically converted into integer as we typed it in
  the header as `created:i`.


pkgId: 49ac075311522fb2b775112fac270f0619a752e4a17182090f58a2a2dcd19577
name: python-csvfilter
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/codeinthehole/csvfilter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvfilter-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  A command-line utility and Python API for manipulating CSV data, eg plucking columns and reordering them.  It's a bit like the unix utility 'cut'


pkgId: 8d74fada37393942c28b57b6b723438608dcdd2bf41efdb252ad348f82ecc64c
name: python-csvformatmail
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A tool to send many mails from csv and a template
url: https://pypi.org/project/csvformatmail/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvformatmail-1.0.2-1.src.rpm
checksum_type: sha256
description:
  From pypi:

  ```
  pipx install csvformatmail
  ```

  You can also use `pip` if you do not want to install in a contained environnement.

  Or developer version:

  ```
  git clone <this repo>
  cd csvformatmail
  pip3 install -e .
  ```



  ```
  mkdir -p ~/.local/share/bash-completion/completions
  register-python-argcomplete csvformatmail > ~/.local/share/bash-completion/completions/csvformatmail
  ```



  Write a mail template:

  ```
  From: My name <my-mail-address@example.org>
  To: {{mail}}
  Bcc: my-mail-address@example.org
  Subject: Result of the last test

  Dear {{firstname}} {{lastname.capitalize()}},

  Your results of the last test are:

   - Part A: {{"{:.1f}".format(a)}}
   - Part B: {{"{:.1f}".format(b)}}

  Therefore you {% if (a+b)/2>=10 %}pass{%else%}fail{%endif%} the test.
  {% if (a+b)/2<10 %}
  Another test session will be organized soon.
  {%endif%}
  --
  Your teacher
  ```

  Use a csv file with (at least) the columns `firstname`, `lastname`, `mail`, `a`
  and `b`:

  ```
  firstname,lastname,mail,a,b,c
  Jacques,MARTIN,jacques.martin@example.org,12.54441,14,1111.221
  …
  ```

  And the command if you use a distant smtp:

  ```
  csvformatmail -h smtp.example.org -l mylogin template.txt -t a:float -t b:float listing.csv
  ```

  Or if you have a local smtp:

  ```
  csvformatmail template.txt -t a:float -t b:float listing.csv
  ```



  The template file can contain python definition, and all the rows for each
  column is accessible by the names `allrows` (default name, can be changed with
  arg `--allrows-name`). See the following template file:

  ```
  From: My name <my-mail-address@example.org>
  To: {{mail}}
  Bcc: my-mail-address@example.org
  Subject: Result of the last test

  Dear {{firstname}} {{lastname.capitalize()}},

  Your results of the last test are:

   - Part A: {{"{:.1f}".format(a)}}
   - Part B: {{"{:.1f}".format(b)}}

  For you information, the statistics for part A are:
   - mean: {{'{:.2f}'.format(np.mean(allrows['a']))}}
   - standard deviation: {{'{:.2f}'.format(np.std(allrows['a']))}}.

  Therefore you {% if (a+b)/2>=10 %}pass{%else%}fail{%endif%} the test.
  {% if (a+b)/2<10 %}
  Another test session will be organized soon.
  {%endif%}
  --
  Your teacher.
  ```

  And the command if you use a distant smtp:

  ```
  csvformatmail -h smtp.example.org -l mylogin template.txt --np -t a:float -t b:float listing.csv
  ```



  Consider use function `fill` and `indent` of `textwrap` module. For this you
  need use `-b "import textwrap"` or add a python preamble in you template file.
  _e.g._ in a template to rewrap to 72 chars:

  ```
  {{textwrap.fill(somevalue, width=72)}}
  ```

  Or, for rewrap and indent by `> `:

  ```
  {{textwrap.indent(textwrap.fill(somevalue, width=70), "> ")}}
  ```


pkgId: a0f93f202bb88455ba87ea744774c3b3af55ace904f478612cc19b9d8d6495e8
name: python-csvkit
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A suite of command-line tools for working with CSV, the king of tabular file formats.
url: https://github.com/wireservice/csvkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvkit-2.0.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/wireservice/csvkit/workflows/CI/badge.svg
      :target: https://github.com/wireservice/csvkit/actions
      :alt: Build status

  .. image:: https://coveralls.io/repos/wireservice/csvkit/badge.svg?branch=master
      :target: https://coveralls.io/r/wireservice/csvkit
      :alt: Coverage status

  .. image:: https://img.shields.io/pypi/dm/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: Support Python versions

  csvkit is a suite of command-line tools for converting to and working with CSV, the king of tabular file formats.

  It is inspired by pdftk, GDAL and the original csvcut tool by Joe Germuska and Aaron Bycoffe.

  Important links:

  * Documentation: https://csvkit.rtfd.org/
  * Repository:    https://github.com/wireservice/csvkit
  * Issues:        https://github.com/wireservice/csvkit/issues
  * Schemas:       https://github.com/wireservice/ffs


pkgId: 3d60ea7f7868b31f58fe0e1ebf2217ba069034ad8894c47abadf718b62de67cf
name: python-csvpath
arch: src
version: 0.0.483
epoch: 0
release: 1
summary: A declarative language for data extraction and validation of CSV files
url: https://pypi.org/project/csvpath/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvpath-0.0.483-1.src.rpm
checksum_type: sha256
description:
  CsvPath defines a declarative syntax for inspecting and validating CSV files.

  CsvPath' goal is to make it easy to:
  - Analyze the content and structure of a CSV
  - Validate that the file matches expectations
  - Report on the content or validity
  - Create new derived CSV files

  And do it all in an automation-friendly way.

  Though much simpler, it is inspired by:
  - XPath. CsvPath is to CSV files like XPath is to XML files.
  - Validation of XML using <a href='https://schematron.com/'>Schematron rules</a>

  CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. New functions are easy to create.

  Read more about CsvPath and see realistic CSV validation examples at <a href='https://www.csvpath.org'>https://www.csvpath.org</a>.

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/csvpath?logoColor=green&color=green) ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/dk107dk/csvpath) ![PyPI - Version](https://img.shields.io/pypi/v/csvpath)




  - [Motivation](#motivation)
  - [High-level Description](#description)
  - [Running CsvPath](#running)
     - [Validation](#validating)
     - [Creating new files](#newfiles)
  - [Comments](#top-comments)
  - [Scanning](#scanning)
  - [Matching](#matching)
     - [Match Components](#components)
        - [Terms](#terms)
        - [Functions](#functions)
        - [Headers](#headers)
        - [Variables](#variables)
        - [Equalities](#equalities)
        - [References](#references)
     - [Comments Within Match](#comments)
     - [The When Operator](#when)
     - [Qualifiers](#qualifiers)
     - [Error Handling](#errors)
  - [More Examples](#examples)
  - [Grammar](#grammar)

  <a name="motivation"></a>


  CSV files are everywhere!

  A surprisingly large number of companies depend on CSV processing for significant amounts of revenue. Research organizations are awash in CSV. And everyone's favorite issue tracker, database GUI, spreadsheet, APM platform, and most any other type of tool we use day to day uses CSV for sharing. CSV is the lowest of common dominators. Many CSVs are invalid or broken in some way. Often times a lot of manual effort goes into finding problems and fixing them.

  CsvPath is first and foremost a validation language. It is intended to describe CSV files in simple declarative rules that indicate if a file is as expected. CsvPath can also extract data, create reports, and in other ways have useful side effects.

  CsvPath's goal is to make simple validations almost trivial and more complex situations more manageable. It is a library, not a system, so it relies on being easy to integrate with other DataOps tools.


  <a name="description"></a>

  CsvPath paths have three parts:
  - a "root" file name
  - a scanning part
  - a matching part

  The root of a csvpath starts with `$`. The match and scan parts are enclosed by brackets. Newlines are ignored.

  A very simple csvpath might look like this:

  ```bash
      $filename[*][yes()]
  ```

  This csvpath says open the file named `filename`, scan all the lines, and match every line scanned.

  A slightly more functional csvpath could look like this:

  ```bash
      $people.csv[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This csvpath reads `people.csv`, counting the people without a middle name and printing the result after the last row is read.

  A csvpath doesn't have to point to a specific file. As shown above, it can point to a specific file or it can instead use a logical name associated with a physical file or have no specific file indicator.

  ```bash
      $[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This version of the example has its file chosen at runtime.

  See [more examples here](#examples).

  There is no limit to the amount of functionality you can include in a single csvpath. However, different functions run with their own performance characteristics. You should plan to test both the performance and functionality of your paths.

  CsvPath was conceived as a data testing and extraction tool. Running it in production typically involves testing the paths in advance and automating the runs.

  Interactive use of csvpaths can be valuable, too, of course. There is a trivial REPL (read–eval–print loop) script at the project's root (<a href='repl.py'>repl.py</a>) that you can use to explore and test csvpaths.

  <a name="running"></a>


  CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/dk107dk/csvpath'>git repo is here</a>.

  Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.


  (<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
  The CsvPath class is the basic entry point for running csvpaths.
  |method                      |function                                                        |
  |----------------------------|----------------------------------------------------------------|
  | parse(csvpath)             | applies a csvpath                                              |
  | next()                     | iterates over matched rows returning each matched row as a list|
  | fast_forward()             | iterates over the file collecting variables and side effects   |
  | advance(n)                 | skips forward n rows from within a `for row in path.next()` loop|
  | collect(n)                 | processes n rows and collects the lines that matched as lists  |


  (<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpaths.py'>code</a>)
  The CsvPaths class helps you manage validations of multiple files and/or multiple csvpaths. It coordinates the work of multiple CsvPath instances.
  |method                |function                                                         |
  |----------------------|-----------------------------------------------------------------|
  | csvpath()            | gets a CsvPath object that knows all the file names available   |
  | collect_paths()      | Same as CsvPath.collect() but for all paths sequentially        |
  | fast_forward_paths() | Same as CsvPath.fast_forward() but for all paths sequentially   |
  | next_paths()         | Same as CsvPath.next() but for all paths sequentially           |
  | collect_by_line()    | Same as CsvPath.collect() but for all paths breadth first       |
  | fast_forward_by_line()| Same as CsvPath.fast_forward() but for all paths breadth first |
  | next_by_line()       | Same as CsvPath.next() but for all paths breadth first          |

  To be clear, the purpose of `CsvPaths` is to apply multiple csvpaths per CSV file. Its breadth-first versions of the `collect()`, `fast_forward()`, and `next()` methods attempt to match each csvpath to each row of a CSV file before continuing to the next row. As you can imagine, for very large files this approach is a must.

  There are several ways to set up CSV file references. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/files.md'>more about managing CSV files</a>.

  You also have important options for managing csvpaths. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about named csvpaths here</a>.

  This is a very basic programmatic use of CsvPath.

  ```python
      path = CsvPath()
      path.parse("""
              $test.csv[5-25][
                  
                  @lastname.onmatch = "Bat"
                  count() == 2
              ]
      """)

      for i, line in enumerate( path.next() ):
          print(f"{i}: {line}")
      print(f"The varibles collected are: {path.variables}")
  ```

  The csvpath says:
  - Open test.csv
  - Scan lines 5 through 25
  - Match the second time we see a line where the first header equals `Frog` and set the variable called  `lastname` to "Bat"

  Another path that does the same thing a bit more simply might look like:

  ```bash
      $test[5-25][
          
          @lastname.onmatch = "Bat"
          count()==2 -> print( "$.csvpath.match_count: $.csvpath.line")
      ]
  ```

  In this case, we're using the "when" operator, `->`, to determine when to print.

  For lots more ideas see the unit tests and [more examples here](#examples).

  There are a small number of configuration options. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/config.md'>more about those here</a>.



  Before we get into the details of scanning and matching, let's look at what CsvPath can print. The `print` function has several important uses, including:

  - Validating CSV files
  - Debugging csvpaths
  - Creating new CSV files based on an existing file

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/printing.md'>read more about the mechanics of printing here</a>.

  <a name="validating"></a>


  CsvPath paths can be used for rules based validation. Rules based validation checks a file against content and structure rules but does not validate the file's structure against a schema. This validation approach is similar to XML's Schematron validation, where XPath rules are applied to XML.

  There is no "standard" way to do CsvPath validation. The simplest way is to create csvpaths that print a validation message when a rule fails. For example:

  ```bash
      $test.csv[*][@failed = equals(#firstname, "Frog")
                   @failed.asbool -> print("Error: Check line $.csvpath.line_count for a row with the name Frog")]
  ```

  Several rules can exist in the same csvpath for convenience and/or performance. Alternatively, you can run separate csvpaths for each rule. You can read more <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about managing csvpaths here</a>.

  <a name="newfiles"></a>


  Csvpaths can also use the `print` function to generate new file content on system out. Redirecting the output to a file is an easy way to create a new CSV file based on an existing file. For e.g.

  ```bash
      $test.csv[*][ line_count()==0 -> print("lastname, firstname, say")
                    above(line_count(), 0) -> print("$.headers.lastname, $.headers.firstname, $.headers.say")]
  ```

  This csvpath reorders the headers of the test file at `tests/test_resources/test.csv`. The output file will have a header row.

  <a name="top-comments"></a>

  CsvPaths have file scanning instructions, match components, and comments. Comments exist at the top level, outside the CsvPath's brackets, as well as in the matching part of the path. Comments within the match part are covered below.

  As well as documentation, comments outside the csvpath can:
  - Contribute to a collection of metadata fields associated with a csvpath
  - Switch on/off certain validation settings
  - Set the identity of a csvpath within a group of csvpaths

  A comment starts and ends with a `~` character. Within the comment, any word that has a colon after it is considered a metadata key. The metadata value is anything following the key up till a new metadata key word is seen or the comment ends.

  For example, this comment says that the csvpath has the name `Order Validation`:

  ```bash
      ~ name: Order Validation
        developer: Abe Sheng
      ~
      $[*][ count(#order) == 10 ]
  ```

  The name `Order Validation` is available in CsvPath's `metadata` property along with the developer's name. You can use any metadata keys you like. All the metadata is available during and after a run, giving you an easy way to name, describe, attribute, etc. your csvpaths.

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/comments.md'>read more about comments and metadata here</a>.

  <a name="scanning"></a>


  The scanning part of a csvpath enumerates selected lines. For each line returned, the line number, the scanned line count, and the match count are available. The set of line numbers scanned is also available.

  The scan part of the path starts with a dollar sign to indicate the root, meaning the file from the top. After the dollar sign comes the file path. The scanning instructions are in a bracket. The rules are:
  - `[*]` means all
  - `[3*]` means starting from line 3 and going to the end of the file
  - `[3]` by itself means just line 3
  - `[1-3]` means lines 1 through 3
  - `[1+3]` means lines 1 and line 3
  - `[1+3-8]` means line 1 and lines 3 through eight

  <a name="matching"></a>


  The match part is also bracketed. Matches have space separated components or "values" that are ANDed together. The components' order is important. A match component is one of several types:

  - Term
  - Function
  - Variable
  - Header
  - Equality
  - Reference

  <a name="Components"></a>
  <a name="terms"></a>

  A string, number, or regular expression value.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | Always true | `"a value"` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/terms.md'>Read about terms here</a>.

  <a name="functions"></a>

  A composable unit of functionality called once for every row scanned.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |Calculated | Calculated | `count()` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>Read about functions here</a>.

  <a name="variables"></a>

  A stored value that is set or retrieved once per row scanned.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | True when set. (Unless the `onchange` qualifier is used). Alone it is an existence test. | `@firstname` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/variables.md'>Read about variables here</a>.

  <a name="headers"></a>

  A named header or a header identified by 0-based index.
  _(CsvPath avoids the word "column" for reasons we'll go into later in the docs)._

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | Calculated. Used alone it is an existence test. | `#area_code` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/headers.md'>Read about headers here</a>.

  <a name="equalities"></a>

  Two of the other types joined with an "=" or "==".

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |Calculated | True at assignment, otherwise calculated. | `#area_code == 617` |

  <a name="references"></a>

  References are a way of pointing to data generated by other csvpaths. Referenced data is held by a CvsPaths instance. It is stored in its named-results. The name is the one that identified the paths that generated it.

  References can point to:
  - Variables
  - Headers

  The form of a reference is:

  ```bash
      $named_path.variables.firstname
  ```

  This reference looks in the results named for its CSV file. The qualifier `variables` indicates the value is a variable named `firstname`.

  |Returns    | Matches                                   | Examples               |
  |-----------|-------------------------------------------|------------------------|
  |Calculated | True at assignment, otherwise calculated. | `@q = $orders.variables.quarter` |


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/references.md'>more about references here</a>.


  <a name="comments"></a>


  You can comment out match components by wrapping them in `~`. Comments can be multi-line. At the moment the only limitations are:

  - Comments cannot include the `~` (tilde) and `]` (right bracket) characters
  - Comments cannot go within match components, only between them

  Examples:

  ```bash
      [ count() ~this is a comment~ ]
  ```

  ```bash
      [    ~this csvpath is
            just for testing.
            use at own risk~
         any()
      ]
  ```

  <a name="when"></a>


  `->`, the "when" operator, is used to act on a condition. `->` can take an equality, header, variable, or function on the left and trigger an assignment or function on the right. For e.g.

  ```bash
      [ last() -> print("this is the last line") ]
  ```

  Prints `this is the last line` just before the scan ends.

  ```bash
      [ exists(#0) -> @firstname = #0 ]
  ```

  Says to set the `firstname` variable to the value of the first column when the first column has a value. (Note that this could be achieved other simpler ways, including using the `notnone` qualifier on the variable.)

  <a name="qualifiers"></a>


  Qualifiers are tokens added to variable, header, and function names. They are separated from the names and each other with `.` characters. Each qualifier causes the qualified match component to behave in a different way than it otherwise would.

  Qualifiers are quite powerful and deserve a close look. <a href='https://github.com/dk107dk/csvpath/blob/main/docs/qualifiers.md'>Read about qualifiers here.</a>

  <a name="errors"></a>


  The CsvPath library handles errors according to policies set for the CsvPath and CsvPaths classes. Each class can have multiple approaches to errors configured together. The options are:
  - Collect - an error collector collects errors for later inspection
  - Raise - an exception is (re)raised that may halt the CsvPath process
  - Stop - the CsvPath instance containing the offending problem is stopped; any others continue
  - Fail - the CsvPath instance containing the offending problem is failed; processing continues
  - Quiet - minimal error information is logged but otherwise handling is quiet

  Raise and quiet are not useful together, but the others combine well. You can set the error policy in the config.ini that lives by default in the ./config directory.

  Because of this nuanced approach to errors, the library will tend to raise data exceptions rather than handle them internally at the point of error. This is particularly true of matching, and especially the functions. When a function sees a problem, or fails to anticipate a problem, the exception is bubbled up to the top Expression within the list of Expressions held by the Matcher. From there it is routed to an error handler to be kept with other results of the run, or an exception is re-raised, or other actions are taken.


  <a name="examples"></a>


  There are more examples scattered throughout the documentation. Good places to look include:

  - Here are a few <a href='https://github.com/dk107dk/csvpath/blob/main/docs/examples.md'>more real-looking examples</a>
  - Try the Getting Started examples on <a href="https://www.csvpath.org">https://www.csvpath.org</a>
  - The individual <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>function descriptions</a>
  - The <a href='https://github.com/dk107dk/csvpath/tree/main/tests'>unit tests</a> and <a href='https://github.com/dk107dk/csvpath/tree/main/tests/grammar/match'>their match parts</a> are not realistic, but a good source of ideas.

  To create example CsvPaths from your own data, try <a href='https://autogen.csvpath.org'>CsvPath AutoGen</a>. The huge caveat is that AutoGen uses AI so your results will not be perfect. You will need to adjust, polish, and test them.

  <a name="grammar"></a>


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/grammar.md'>more about the CsvPath grammar definition here</a>.




  Visit <a href="https://www.csvpath.org">https://www.csvpath.org</a>



  <a href='https://www.atestaanalytics.com/' >
  <img width="25%" src="https://raw.githubusercontent.com/dk107dk/csvpath/main/docs/images/logo-wordmark-white-on-black-trimmed-padded.png" alt="Atesta Analytics"/></a>
      <a href='https://www.datakitchen.io/'>
  <img src="https://datakitchen.io/wp-content/uploads/2020/10/logo.svg"
  style='width:160px; position:relative;bottom:-5px;left:15px' alt="DataKitchen" id="logo" data-height-percentage="45"></a>


pkgId: ac05ee2a2e2d93101606ab30b44bee5279bcbda06493225c79c5175cc2be861a
name: python-csvpath
arch: src
version: 0.0.490
epoch: 0
release: 1
summary: A declarative language for validating CSV, Excel, and other tabular data files
url: https://pypi.org/project/csvpath/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvpath-0.0.490-1.src.rpm
checksum_type: sha256
description:
  CsvPath defines a declarative syntax for inspecting and validating CSV and Excel files, and other tabular data.

  CsvPath's goal is to make it easy to setup a Collect, Store, Validate-pattern flat-file landing zone that:
  - Analyzes the content and structure of flat files
  - Validates that files match expectations
  - Reports on content validity
  - Creates new derived files using copy-on-write

  And does it all in an automation-friendly way.

  CsvPath's validation is inspired by:
  - XPath for XML files
  - The ISO standard <a href='https://schematron.com/'>Schematron validation</a>

  CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. Metadata is plentiful. New functions are easy to create.

  Read more about CsvPath and see realistic CSV and Excel validation examples at <a href='https://www.csvpath.org'>https://www.csvpath.org</a>.

  If you need help, use the <a href='https://www.csvpath.org/getting-started/get-help'>contact form</a> or the <a href='https://github.com/csvpath/csvpath/issues'>issue tracker</a> or talk to one of our [sponsors](#sponsors).

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/csvpath?logoColor=green&color=green) ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/dk107dk/csvpath) ![PyPI - Version](https://img.shields.io/pypi/v/csvpath)




  - [Motivation](#motivation)
  - [Install](#install)
  - [High-level Description](#description)
  - [Running CsvPath](#running)
     - [Validation](#validating)
     - [Creating new files](#newfiles)
  - [Comments](#top-comments)
  - [Scanning](#scanning)
  - [Matching](#matching)
     - [Match Components](#components)
        - [Terms](#terms)
        - [Functions](#functions)
        - [Headers](#headers)
        - [Variables](#variables)
        - [Equalities](#equalities)
        - [References](#references)
     - [Comments Within Match](#comments)
     - [The When Operator](#when)
     - [Qualifiers](#qualifiers)
     - [Error Handling](#errors)
  - [More Examples](#examples)
  - [Grammar](#grammar)
  - [Sponsors](#sponsors)

  <a name="motivation"></a>


  CSV files are everywhere!

  A surprisingly large number of companies depend on CSV processing for significant amounts of revenue. Research organizations are awash in CSV. And everyone's favorite issue tracker, database GUI, spreadsheet, APM platform, and most any other type of tool we use day to day uses CSV for sharing. CSV is the lowest of common dominators. Many CSVs are invalid or broken in some way. Often times a lot of manual effort goes into finding problems and fixing them.

  CsvPath is first and foremost a validation language. It describes tabular data in simple declarative rules that define what valid means for that data. CsvPath can also extract data, create reports, and do other useful things.

  CsvPath's goal is to make simple validations almost trivial and more complex situations more manageable. It is a library, not a system, so it relies on being easy to integrate with other DataOps tools.


  <a name="install"></a>


  <a href='https://pypi.org/project/csvpath/'>CsvPath is available on PyPi</a>. Install with
  ```
      pip install csvpath
  ```

  CsvPath has two optional dependencies:

  - <a target='_blank' href='https://pypi.org/project/pandas/'>Pandas</a>
  - <a target='_blank' href='https://pypi.org/project/smart-open/'>Smart-open</a>

  Pandas data frames can be used as a data source, much like Excel or CSV files. Install CsvPath with the Pandas option:
  ```
      pip install csvpath[pandas]
  ```

  Smart-open is an option for loading data files directly from S3. Install the Smart Open extra with:
  ```
      pip install csvpath[smart-open]
  ```

  Both of these optional dependencies can make it harder to use CsvPath in certain specific use cases. For e.g., using Pandas in an AWS Lambda layer may be less straightforward. If you need the capabilities, they are easy to install, but if you don't CsvPath is lighter weight without.



  <a name="description"></a>

  CsvPath paths have three parts:
  - a "root" file name
  - a scanning part
  - a matching part

  The root of a csvpath starts with `$`. The match and scan parts are enclosed by brackets. Newlines are ignored.

  A very simple csvpath might look like this:

  ```bash
      $filename[*][yes()]
  ```

  This csvpath says open the file named `filename`, scan all the lines, and match every line scanned.

  A slightly more functional csvpath could look like this:

  ```bash
      $people.csv[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This csvpath reads `people.csv`, counting the people without a middle name and printing the result after the last row is read.

  A csvpath doesn't have to point to a specific file. As shown above, it can point to a specific file or it can instead use a logical name associated with a physical file or have no specific file indicator.

  ```bash
      $[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This version of the example has its file chosen at runtime.

  See [more examples here](#examples).

  There is no limit to the amount of functionality you can include in a single csvpath. However, different functions run with their own performance characteristics. You should plan to test both the performance and functionality of your paths.

  CsvPath was conceived as a data testing and extraction tool. Running it in production typically involves testing the paths in advance and automating the runs.

  Interactive use of csvpaths can be valuable, too, of course. There is a trivial REPL (read–eval–print loop) script at the project's root (<a href='repl.py'>repl.py</a>) that you can use to explore and test csvpaths.

  <a name="running"></a>


  CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/csvpath/csvpath'>git repo is here</a>.

  Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.


  (<a href='https://github.com/csvpath/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
  The CsvPath class is the basic entry point for running csvpaths.
  |method                      |function                                                         |
  |----------------------------|-----------------------------------------------------------------|
  | next()                     | iterates over matched rows returning each matched row as a list |
  | fast_forward()             | iterates over the file collecting variables and side effects    |
  | advance()                  | skips forward n rows from within a `for row in path.next()` loop|
  | collect()                  | processes n rows and collects the lines that matched as lists   |


  (<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpaths.py'>code</a>)
  The CsvPaths class helps you manage validations of multiple files and/or multiple csvpaths. It coordinates the work of multiple CsvPath instances.
  |method                  |function                                                         |
  |------------------------|-----------------------------------------------------------------|
  | csvpath()              | gets a CsvPath object that knows all the file names available   |
  | collect_paths()        | Same as CsvPath.collect() but for all paths sequentially        |
  | fast_forward_paths()   | Same as CsvPath.fast_forward() but for all paths sequentially   |
  | next_paths()           | Same as CsvPath.next() but for all paths sequentially           |
  | collect_by_line()      | Same as CsvPath.collect() but for all paths breadth first       |
  | fast_forward_by_line() | Same as CsvPath.fast_forward() but for all paths breadth first  |
  | next_by_line()         | Same as CsvPath.next() but for all paths breadth first          |

  To be clear, the purpose of `CsvPaths` is to apply multiple csvpaths per CSV file. Its breadth-first versions of the `collect()`, `fast_forward()`, and `next()` methods attempt to match each csvpath to each row of a CSV file before continuing to the next row. As you can imagine, for very large files this approach is a must.

  There are several ways to set up CSV file references. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/files.md'>more about managing CSV files</a>.

  You also have important options for managing csvpaths. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about named csvpaths here</a>.

  This is a very basic programmatic use of CsvPath.

  ```python
      path = CsvPath()
      path.parse("""
              $test.csv[5-25][
                  
                  @lastname.onmatch = "Bat"
                  count() == 2
              ]
      """)

      for i, line in enumerate( path.next() ):
          print(f"{i}: {line}")
      print(f"The varibles collected are: {path.variables}")
  ```

  The csvpath says:
  - Open test.csv
  - Scan lines 5 through 25
  - Match the second time we see a line where the first header equals `Frog` and set the variable called  `lastname` to "Bat"

  Another path that does the same thing a bit more simply might look like:

  ```bash
      $test[5-25][
          
          @lastname.onmatch = "Bat"
          count()==2 -> print( "$.csvpath.match_count: $.csvpath.line")
      ]
  ```

  In this case, we're using the "when" operator, `->`, to determine when to print.

  For lots more ideas see the unit tests and [more examples here](#examples).

  There are a small number of configuration options. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/config.md'>more about those here</a>.



  Before we get into the details of scanning and matching, let's look at what CsvPath can print. The `print` function has several important uses, including:

  - Validating CSV files
  - Debugging csvpaths
  - Creating new CSV files based on an existing file

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/printing.md'>read more about the mechanics of printing here</a>.

  <a name="validating"></a>


  CsvPath paths can be used for rules based validation. Rules based validation checks a file against content and structure rules but does not validate the file's structure against a schema. This validation approach is similar to XML's Schematron validation, where XPath rules are applied to XML.

  There is no "standard" way to do CsvPath validation. The simplest way is to create csvpaths that print a validation message when a rule fails. For example:

  ```bash
      $test.csv[*][@failed = equals(#firstname, "Frog")
                   @failed.asbool -> print("Error: Check line $.csvpath.line_count for a row with the name Frog")]
  ```

  Several rules can exist in the same csvpath for convenience and/or performance. Alternatively, you can run separate csvpaths for each rule. You can read more <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about managing csvpaths here</a>.

  <a name="newfiles"></a>


  Csvpaths can also use the `print` function to generate new file content on system out. Redirecting the output to a file is an easy way to create a new CSV file based on an existing file. For e.g.

  ```bash
      $test.csv[*][ line_count()==0 -> print("lastname, firstname, say")
                    above(line_count(), 0) -> print("$.headers.lastname, $.headers.firstname, $.headers.say")]
  ```

  This csvpath reorders the headers of the test file at `tests/test_resources/test.csv`. The output file will have a header row.

  <a name="top-comments"></a>

  CsvPaths have file scanning instructions, match components, and comments. Comments exist at the top level, outside the CsvPath's brackets, as well as in the matching part of the path. Comments within the match part are covered below.

  As well as documentation, comments outside the csvpath can:
  - Contribute to a collection of metadata fields associated with a csvpath
  - Switch on/off certain validation settings
  - Set the identity of a csvpath within a group of csvpaths

  A comment starts and ends with a `~` character. Within the comment, any word that has a colon after it is considered a metadata key. The metadata value is anything following the key up till a new metadata key word is seen or the comment ends.

  For example, this comment says that the csvpath has the name `Order Validation`:

  ```bash
      ~ name: Order Validation
        developer: Abe Sheng
      ~
      $[*][ count(#order) == 10 ]
  ```

  The name `Order Validation` is available in CsvPath's `metadata` property along with the developer's name. You can use any metadata keys you like. All the metadata is available during and after a run, giving you an easy way to name, describe, attribute, etc. your csvpaths.

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/comments.md'>read more about comments and metadata here</a>.

  <a name="scanning"></a>


  The scanning part of a csvpath enumerates selected lines. For each line returned, the line number, the scanned line count, and the match count are available. The set of line numbers scanned is also available.

  The scan part of the path starts with a dollar sign to indicate the root, meaning the file from the top. After the dollar sign comes the file path. The scanning instructions are in a bracket. The rules are:
  - `[*]` means all
  - `[3*]` means starting from line 3 and going to the end of the file
  - `[3]` by itself means just line 3
  - `[1-3]` means lines 1 through 3
  - `[1+3]` means lines 1 and line 3
  - `[1+3-8]` means line 1 and lines 3 through eight

  <a name="matching"></a>


  The match part is also bracketed. Matches have space separated components or "values" that are ANDed together. The components' order is important. A match component is one of several types:

  - Term
  - Function
  - Variable
  - Header
  - Equality
  - Reference

  <a name="Components"></a>
  <a name="terms"></a>

  A string, number, or regular expression value.

  |Returns | Matches     | Examples        |
  |--------|-------------|-----------------|
  |A value | Always true | `"a value"`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/terms.md'>Read about terms here</a>.

  <a name="functions"></a>

  A composable unit of functionality called once for every row scanned.

  |Returns    | Matches    | Examples      |
  |-----------|------------|---------------|
  |Calculated | Calculated | `count()`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>Read about functions here</a>.

  <a name="variables"></a>

  A stored value that is set or retrieved once per row scanned.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | True when set. (Unless the `onchange` qualifier is used). Alone it is an existence test. | `@firstname` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/variables.md'>Read about variables here</a>.

  <a name="headers"></a>

  A named header or a header identified by 0-based index.
  _(CsvPath avoids the word "column" for reasons we'll go into later in the docs)._

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | Calculated. Used alone it is an existence test. | `#area_code` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/headers.md'>Read about headers here</a>.

  <a name="equalities"></a>

  Two of the other types joined with an "=" or "==".

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |Calculated | True at assignment, otherwise calculated. | `#area_code == 617` |

  <a name="references"></a>

  References are a way of pointing to data generated by other csvpaths. Referenced data is held by a CvsPaths instance. It is stored in its named-results. The name is the one that identified the paths that generated it.

  References can point to:
  - Variables
  - Headers

  The form of a reference is:

  ```bash
      $named_path.variables.firstname
  ```

  This reference looks in the results named for its CSV file. The qualifier `variables` indicates the value is a variable named `firstname`.

  |Returns    | Matches                                   | Examples               |
  |-----------|-------------------------------------------|------------------------|
  |Calculated | True at assignment, otherwise calculated. | `@q = $orders.variables.quarter` |


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/references.md'>more about references here</a>.


  <a name="comments"></a>


  You can comment out match components by wrapping them in `~`. Comments can be multi-line. At the moment the only limitations are:

  - Comments cannot include the `~` (tilde) and `]` (right bracket) characters
  - Comments cannot go within match components, only between them

  Examples:

  ```bash
      [ count() ~this is a comment~ ]
  ```

  ```bash
      [    ~this csvpath is
            just for testing.
            use at own risk~
         any()
      ]
  ```

  <a name="when"></a>


  `->`, the "when" operator, is used to act on a condition. `->` can take an equality, header, variable, or function on the left and trigger an assignment or function on the right. For e.g.

  ```bash
      [ last() -> print("this is the last line") ]
  ```

  Prints `this is the last line` just before the scan ends.

  ```bash
      [ exists(#0) -> @firstname = #0 ]
  ```

  Says to set the `firstname` variable to the value of the first column when the first column has a value. (Note that this could be achieved other simpler ways, including using the `notnone` qualifier on the variable.)

  <a name="qualifiers"></a>


  Qualifiers are tokens added to variable, header, and function names. They are separated from the names and each other with `.` characters. Each qualifier causes the qualified match component to behave in a different way than it otherwise would.

  Qualifiers are quite powerful and deserve a close look. <a href='https://github.com/dk107dk/csvpath/blob/main/docs/qualifiers.md'>Read about qualifiers here.</a>

  <a name="errors"></a>


  The CsvPath library handles errors according to policies set for the CsvPath and CsvPaths classes. Each class can have multiple approaches to errors configured together. The options are:
  - Collect - an error collector collects errors for later inspection
  - Raise - an exception is (re)raised that may halt the CsvPath process
  - Stop - the CsvPath instance containing the offending problem is stopped; any others continue
  - Fail - the CsvPath instance containing the offending problem is failed; processing continues
  - Quiet - minimal error information is logged but otherwise handling is quiet

  Raise and quiet are not useful together, but the others combine well. You can set the error policy in the config.ini that lives by default in the ./config directory.

  Because of this nuanced approach to errors, the library will tend to raise data exceptions rather than handle them internally at the point of error. This is particularly true of matching, and especially the functions. When a function sees a problem, or fails to anticipate a problem, the exception is bubbled up to the top Expression within the list of Expressions held by the Matcher. From there it is routed to an error handler to be kept with other results of the run, or an exception is re-raised, or other actions are taken.


  <a name="examples"></a>


  There are more examples scattered throughout the documentation. Good places to look include:

  - Here are a few <a href='https://github.com/dk107dk/csvpath/blob/main/docs/examples.md'>more real-looking examples</a>
  - Try the Getting Started examples on <a href="https://www.csvpath.org">https://www.csvpath.org</a>
  - The individual <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>function descriptions</a>
  - The <a href='https://github.com/dk107dk/csvpath/tree/main/tests'>unit tests</a> and <a href='https://github.com/dk107dk/csvpath/tree/main/tests/grammar/match'>their match parts</a> are not realistic, but a good source of ideas.

  To create example CsvPaths from your own data, try <a href='https://autogen.csvpath.org'>CsvPath AutoGen</a>. The huge caveat is that AutoGen uses AI so your results will not be perfect. You will need to adjust, polish, and test them.

  <a name="grammar"></a>


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/grammar.md'>more about the CsvPath grammar definition here</a>.


  <a name="more-info"></a>


  Visit <a href="https://www.csvpath.org">https://www.csvpath.org</a>

  <a name="sponsors"></a>


  <a href='https://www.atestaanalytics.com/' >
  <img width="25%" src="https://raw.githubusercontent.com/dk107dk/csvpath/main/docs/images/logo-wordmark-white-on-black-trimmed-padded.png" alt="Atesta Analytics"/></a>
      <a href='https://www.datakitchen.io/'>
  <img src="https://datakitchen.io/wp-content/uploads/2020/10/logo.svg"
  style='width:160px; position:relative;bottom:-5px;left:15px' alt="DataKitchen" id="logo" data-height-percentage="45"></a>


pkgId: 3f72461b98a27c77ca81623cbeb3de11359aa794702836f0b766798b81c6babd
name: python-csvpath
arch: src
version: 0.0.494
epoch: 0
release: 1
summary: A declarative language for validating CSV, Excel, and other tabular data files
url: https://pypi.org/project/csvpath/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvpath-0.0.494-1.src.rpm
checksum_type: sha256
description:
  CsvPath defines a declarative syntax for inspecting and validating CSV and Excel files, and other tabular data.

  CsvPath's goal is to make it easy to setup a Collect, Store, Validate-pattern flat-file landing zone that:
  - Analyzes the content and structure of flat files
  - Validates that files match expectations
  - Reports on content validity
  - Creates new derived files using copy-on-write

  And does it all in an automation-friendly way.

  CsvPath's validation is inspired by:
  - XPath for XML files
  - The ISO standard <a href='https://schematron.com/'>Schematron validation</a>

  CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. Metadata is plentiful. New functions are easy to create.

  Read more about CsvPath and see realistic CSV and Excel validation examples at <a href='https://www.csvpath.org'>https://www.csvpath.org</a>.

  If you need help, use the <a href='https://www.csvpath.org/getting-started/get-help'>contact form</a> or the <a href='https://github.com/csvpath/csvpath/issues'>issue tracker</a> or talk to one of our [sponsors](#sponsors).

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/csvpath?logoColor=green&color=green) ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/dk107dk/csvpath) ![PyPI - Version](https://img.shields.io/pypi/v/csvpath)




  - [Motivation](#motivation)
  - [Install](#install)
  - [High-level Description](#description)
  - [Running CsvPath](#running)
     - [Validation](#validating)
     - [Creating new files](#newfiles)
  - [Comments](#top-comments)
  - [Scanning](#scanning)
  - [Matching](#matching)
     - [Match Components](#components)
        - [Terms](#terms)
        - [Functions](#functions)
        - [Headers](#headers)
        - [Variables](#variables)
        - [Equalities](#equalities)
        - [References](#references)
     - [Comments Within Match](#comments)
     - [The When Operator](#when)
     - [Qualifiers](#qualifiers)
     - [Error Handling](#errors)
  - [More Examples](#examples)
  - [Grammar](#grammar)
  - [Sponsors](#sponsors)

  <a name="motivation"></a>


  CSV files are everywhere!

  A surprisingly large number of companies depend on CSV processing for significant amounts of revenue. Research organizations are awash in CSV. And everyone's favorite issue tracker, database GUI, spreadsheet, APM platform, and most any other type of tool we use day to day uses CSV for sharing. CSV is the lowest of common dominators. Many CSVs are invalid or broken in some way. Often times a lot of manual effort goes into finding problems and fixing them.

  CsvPath is first and foremost a validation language. It describes tabular data in simple declarative rules that define what valid means for that data. CsvPath can also extract data, create reports, and do other useful things.

  CsvPath's goal is to make simple validations almost trivial and more complex situations more manageable. It is a library, not a system, so it relies on being easy to integrate with other DataOps tools.


  <a name="install"></a>


  <a href='https://pypi.org/project/csvpath/'>CsvPath is available on PyPi</a>. Install with
  ```
      pip install csvpath
  ```

  CsvPath has two optional dependencies:

  - <a target='_blank' href='https://pypi.org/project/pandas/'>Pandas</a>
  - <a target='_blank' href='https://pypi.org/project/smart-open/'>Smart-open</a>

  Pandas data frames can be used as a data source, much like Excel or CSV files. Install CsvPath with the Pandas option:
  ```
      pip install csvpath[pandas]
  ```

  Smart-open is an option for loading data files directly from S3. Install the Smart Open extra with:
  ```
      pip install csvpath[smart-open]
  ```

  Both of these optional dependencies can make it harder to use CsvPath in certain specific use cases. For e.g., using Pandas in an AWS Lambda layer may be less straightforward. If you need the capabilities, they are easy to install, but if you don't CsvPath is lighter weight without.



  <a name="description"></a>

  CsvPath paths have three parts:
  - a "root" file name
  - a scanning part
  - a matching part

  The root of a csvpath starts with `$`. The match and scan parts are enclosed by brackets. Newlines are ignored.

  A very simple csvpath might look like this:

  ```bash
      $filename[*][yes()]
  ```

  This csvpath says open the file named `filename`, scan all the lines, and match every line scanned.

  A slightly more functional csvpath could look like this:

  ```bash
      $people.csv[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This csvpath reads `people.csv`, counting the people without a middle name and printing the result after the last row is read.

  A csvpath doesn't have to point to a specific file. As shown above, it can point to a specific file or it can instead use a logical name associated with a physical file or have no specific file indicator.

  ```bash
      $[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This version of the example has its file chosen at runtime.

  See [more examples in this documentation](#examples). There are also <a href='https://www.csvpath.org'>lots more examples on csvpath.org</a>.

  There is no limit to the amount of functionality you can include in a single csvpath. However, different functions run with their own performance characteristics. You should plan to test both the performance and functionality of your paths.

  CsvPath was conceived as a data testing and extraction tool. Running it in production typically involves testing the paths in advance and automating the runs. There is a simple <a href='https://github.com/csvpath/csvpath/cli'>command line interface</a> that you can use to create and test csvpaths. You can <a href='https://www.csvpath.org/getting-started/your-first-validation-the-lazy-way'>read more about the CLI here</a>.

  <a name="running"></a>


  CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/csvpath/csvpath'>git repo is here</a>.

  Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.


  (<a href='https://github.com/csvpath/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
  The CsvPath class is the basic entry point for running csvpaths.
  |method                      |function                                                         |
  |----------------------------|-----------------------------------------------------------------|
  | next()                     | iterates over matched rows returning each matched row as a list |
  | fast_forward()             | iterates over the file collecting variables and side effects    |
  | advance()                  | skips forward n rows from within a `for row in path.next()` loop|
  | collect()                  | processes n rows and collects the lines that matched as lists   |


  (<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpaths.py'>code</a>)
  The CsvPaths class helps you manage validations of multiple files and/or multiple csvpaths. It coordinates the work of multiple CsvPath instances.
  |method                  |function                                                         |
  |------------------------|-----------------------------------------------------------------|
  | csvpath()              | gets a CsvPath object that knows all the file names available   |
  | collect_paths()        | Same as CsvPath.collect() but for all paths sequentially        |
  | fast_forward_paths()   | Same as CsvPath.fast_forward() but for all paths sequentially   |
  | next_paths()           | Same as CsvPath.next() but for all paths sequentially           |
  | collect_by_line()      | Same as CsvPath.collect() but for all paths breadth first       |
  | fast_forward_by_line() | Same as CsvPath.fast_forward() but for all paths breadth first  |
  | next_by_line()         | Same as CsvPath.next() but for all paths breadth first          |

  To be clear, the purpose of `CsvPaths` is to apply multiple csvpaths per CSV file. Its breadth-first versions of the `collect()`, `fast_forward()`, and `next()` methods attempt to match each csvpath to each row of a CSV file before continuing to the next row. As you can imagine, for very large files this approach can be a big win.

  There are several ways to set up CSV file references. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/files.md'>more about managing CSV files</a>.

  You also have important options for managing csvpaths. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about named csvpaths here</a>.

  The simplest way to get started is using the CLI. <a href='https://www.csvpath.org/getting-started/your-first-validation-the-lazy-way'>Read about getting started with the CLI here</a>.

  When you're ready to think about automation, you'll want to start with a simple driver. This is a very basic programmatic use of CsvPath.

  ```python
      path = CsvPath()
      path.parse("""
              $test.csv[5-25][
                  
                  @lastname.onmatch = "Bat"
                  count() == 2
              ]
      """)

      for i, line in enumerate( path.next() ):
          print(f"{i}: {line}")
      print(f"The varibles collected are: {path.variables}")
  ```

  The csvpath says:
  - Open test.csv
  - Scan lines 5 through 25
  - Match the second time we see a line where the first header equals `Frog` and set the variable called  `lastname` to "Bat"

  Another path that does the same thing a bit more simply might look like:

  ```bash
      $test[5-25][
          
          @lastname.onmatch = "Bat"
          count()==2 -> print( "$.csvpath.match_count: $.csvpath.line")
      ]
  ```

  In this case, we're using the "when" operator, `->`, to determine when to print.

  For lots more ideas see the unit tests and [more examples here](#examples).

  There are a small number of configuration options. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/config.md'>more about those here</a>.



  Before we get into the details of scanning and matching, let's look at what CsvPath can print. The `print` function has several important uses, including:

  - Validating CSV files
  - Debugging csvpaths
  - Creating new CSV files based on an existing file

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/printing.md'>read more about the mechanics of printing here</a>.

  <a name="validating"></a>


  CsvPath paths can be used for rules based validation. Rules based validation checks a file against content and structure rules but does not validate the file's structure against a schema. This validation approach is similar to XML's Schematron validation, where XPath rules are applied to XML.

  There is no "standard" way to do CsvPath validation. The simplest way is to create csvpaths that print a validation message when a rule fails. For example:

  ```bash
      $test.csv[*][@failed = equals(#firstname, "Frog")
                   @failed.asbool -> print("Error: Check line $.csvpath.line_count for a row with the name Frog")]
  ```

  Several rules can exist in the same csvpath for convenience and/or performance. Alternatively, you can run separate csvpaths for each rule. You can read more <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about managing csvpaths here</a>.

  <a name="newfiles"></a>


  Csvpaths can also use the `print` function to generate new file content on system out. Redirecting the output to a file is an easy way to create a new CSV file based on an existing file. For e.g.

  ```bash
      $test.csv[*][ line_count()==0 -> print("lastname, firstname, say")
                    above(line_count(), 0) -> print("$.headers.lastname, $.headers.firstname, $.headers.say")]
  ```

  This csvpath reorders the headers of the test file at `tests/test_resources/test.csv`. The output file will have a header row.

  <a name="top-comments"></a>

  CsvPaths have file scanning instructions, match components, and comments. Comments exist at the top level, outside the CsvPath's brackets, as well as in the matching part of the path. Comments within the match part are covered below.

  As well as documentation, comments outside the csvpath can:
  - Contribute to a collection of metadata fields associated with a csvpath
  - Switch on/off certain validation settings
  - Set the identity of a csvpath within a group of csvpaths

  A comment starts and ends with a `~` character. Within the comment, any word that has a colon after it is considered a metadata key. The metadata value is anything following the key up till a new metadata key word is seen or the comment ends.

  For example, this comment says that the csvpath has the name `Order Validation`:

  ```bash
      ~ name: Order Validation
        developer: Abe Sheng
      ~
      $[*][ count(#order) == 10 ]
  ```

  The name `Order Validation` is available in CsvPath's `metadata` property along with the developer's name. You can use any metadata keys you like. All the metadata is available during and after a run, giving you an easy way to name, describe, attribute, etc. your csvpaths.

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/comments.md'>read more about comments and metadata here</a>.

  <a name="scanning"></a>


  The scanning part of a csvpath enumerates selected lines. For each line returned, the line number, the scanned line count, and the match count are available. The set of line numbers scanned is also available.

  The scan part of the path starts with a dollar sign to indicate the root, meaning the file from the top. After the dollar sign comes the file path. The scanning instructions are in a bracket. The rules are:
  - `[*]` means all
  - `[3*]` means starting from line 3 and going to the end of the file
  - `[3]` by itself means just line 3
  - `[1-3]` means lines 1 through 3
  - `[1+3]` means lines 1 and line 3
  - `[1+3-8]` means line 1 and lines 3 through eight

  <a name="matching"></a>


  The match part is also bracketed. Matches have space separated components or "values" that are ANDed together. The components' order is important. A match component is one of several types:

  - Term
  - Function
  - Variable
  - Header
  - Equality
  - Reference

  <a name="Components"></a>
  <a name="terms"></a>

  A string, number, or regular expression value.

  |Returns | Matches     | Examples        |
  |--------|-------------|-----------------|
  |A value | Always true | `"a value"`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/terms.md'>Read about terms here</a>.

  <a name="functions"></a>

  A composable unit of functionality called once for every row scanned.

  |Returns    | Matches    | Examples      |
  |-----------|------------|---------------|
  |Calculated | Calculated | `count()`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>Read about functions here</a>.

  <a name="variables"></a>

  A stored value that is set or retrieved once per row scanned.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | True when set. (Unless the `onchange` qualifier is used). Alone it is an existence test. | `@firstname` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/variables.md'>Read about variables here</a>.

  <a name="headers"></a>

  A named header or a header identified by 0-based index.
  _(CsvPath avoids the word "column" for reasons we'll go into later in the docs)._

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | Calculated. Used alone it is an existence test. | `#area_code` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/headers.md'>Read about headers here</a>.

  <a name="equalities"></a>

  Two of the other types joined with an "=" or "==".

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |Calculated | True at assignment, otherwise calculated. | `#area_code == 617` |

  <a name="references"></a>

  References are a way of pointing to data generated by other csvpaths. Referenced data is held by a CvsPaths instance. It is stored in its named-results. The name is the one that identified the paths that generated it.

  References can point to:
  - Variables
  - Headers

  The form of a reference is:

  ```bash
      $named_path.variables.firstname
  ```

  This reference looks in the results named for its CSV file. The qualifier `variables` indicates the value is a variable named `firstname`.

  |Returns    | Matches                                   | Examples               |
  |-----------|-------------------------------------------|------------------------|
  |Calculated | True at assignment, otherwise calculated. | `@q = $orders.variables.quarter` |


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/references.md'>more about references here</a>.


  <a name="comments"></a>


  You can comment out match components by wrapping them in `~`. Comments can be multi-line. At the moment the only limitations are:

  - Comments cannot include the `~` (tilde) and `]` (right bracket) characters
  - Comments cannot go within match components, only between them

  Examples:

  ```bash
      [ count() ~this is a comment~ ]
  ```

  ```bash
      [    ~this csvpath is
            just for testing.
            use at own risk~
         any()
      ]
  ```

  <a name="when"></a>


  `->`, the "when" operator, is used to act on a condition. `->` can take an equality, header, variable, or function on the left and trigger an assignment or function on the right. For e.g.

  ```bash
      [ last() -> print("this is the last line") ]
  ```

  Prints `this is the last line` just before the scan ends.

  ```bash
      [ exists(#0) -> @firstname = #0 ]
  ```

  Says to set the `firstname` variable to the value of the first column when the first column has a value. (Note that this could be achieved other simpler ways, including using the `notnone` qualifier on the variable.)

  <a name="qualifiers"></a>


  Qualifiers are tokens added to variable, header, and function names. They are separated from the names and each other with `.` characters. Each qualifier causes the qualified match component to behave in a different way than it otherwise would.

  Qualifiers are quite powerful and deserve a close look. <a href='https://github.com/dk107dk/csvpath/blob/main/docs/qualifiers.md'>Read about qualifiers here.</a>

  <a name="errors"></a>


  The CsvPath library handles errors according to policies set for the CsvPath and CsvPaths classes. Each class can have multiple approaches to errors configured together. The options are:
  - Collect - an error collector collects errors for later inspection
  - Raise - an exception is (re)raised that may halt the CsvPath process
  - Stop - the CsvPath instance containing the offending problem is stopped; any others continue
  - Fail - the CsvPath instance containing the offending problem is failed; processing continues
  - Quiet - minimal error information is logged but otherwise handling is quiet

  Raise and quiet are not useful together, but the others combine well. You can set the error policy in the config.ini that lives by default in the ./config directory.

  Because of this nuanced approach to errors, the library will tend to raise data exceptions rather than handle them internally at the point of error. This is particularly true of matching, and especially the functions. When a function sees a problem, or fails to anticipate a problem, the exception is bubbled up to the top Expression within the list of Expressions held by the Matcher. From there it is routed to an error handler to be kept with other results of the run, or an exception is re-raised, or other actions are taken.


  <a name="examples"></a>


  There are more examples scattered throughout the documentation. Good places to look include:

  - Here are a few <a href='https://github.com/dk107dk/csvpath/blob/main/docs/examples.md'>more real-looking examples</a>
  - Try the Getting Started examples on <a href="https://www.csvpath.org">https://www.csvpath.org</a>
  - The individual <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>function descriptions</a>
  - The <a href='https://github.com/dk107dk/csvpath/tree/main/tests'>unit tests</a> and <a href='https://github.com/dk107dk/csvpath/tree/main/tests/grammar/match'>their match parts</a> are not realistic, but a good source of ideas.

  To create example CsvPaths from your own data, try <a href='https://autogen.csvpath.org'>CsvPath AutoGen</a>. The huge caveat is that AutoGen uses AI so your results will not be perfect. You will need to adjust, polish, and test them.

  <a name="grammar"></a>


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/grammar.md'>more about the CsvPath grammar definition here</a>.


  <a name="more-info"></a>


  Visit <a href="https://www.csvpath.org">https://www.csvpath.org</a>

  <a name="sponsors"></a>


  <a href='https://www.atestaanalytics.com/' >
  <img width="25%" src="https://raw.githubusercontent.com/dk107dk/csvpath/main/docs/images/logo-wordmark-white-on-black-trimmed-padded.png" alt="Atesta Analytics"/></a>
      <a href='https://www.datakitchen.io/'>
  <img src="https://datakitchen.io/wp-content/uploads/2020/10/logo.svg"
  style='width:160px; position:relative;bottom:-5px;left:15px' alt="DataKitchen" id="logo" data-height-percentage="45"></a>


pkgId: 0acbe7390d8c4d65465b4bbd7efac2615bb07cd24149eb10fea63b099a9a9c27
name: python-csvs-to-sqlite
arch: src
version: 1.3
epoch: 0
release: 1
summary: Convert CSV files into a SQLite database
url: https://github.com/simonw/csvs-to-sqlite
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvs-to-sqlite-1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/csvs-to-sqlite.svg)](https://pypi.org/project/csvs-to-sqlite/)
  [![Changelog](https://img.shields.io/github/v/release/simonw/csvs-to-sqlite?include_prereleases&label=changelog)](https://github.com/simonw/csvs-to-sqlite/releases)
  [![Tests](https://github.com/simonw/csvs-to-sqlite/workflows/Test/badge.svg)](https://github.com/simonw/csvs-to-sqlite/actions?query=workflow%3ATest)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/csvs-to-sqlite/blob/main/LICENSE)

  Convert CSV files into a SQLite database. Browse and publish that SQLite database with [Datasette](https://github.com/simonw/datasette).

  Basic usage:

      csvs-to-sqlite myfile.csv mydatabase.db

  This will create a new SQLite database called `mydatabase.db` containing a
  single table, `myfile`, containing the CSV content.

  You can provide multiple CSV files:

      csvs-to-sqlite one.csv two.csv bundle.db

  The `bundle.db` database will contain two tables, `one` and `two`.

  This means you can use wildcards:

      csvs-to-sqlite ~/Downloads/*.csv my-downloads.db

  If you pass a path to one or more directories, the script will recursively
  search those directories for CSV files and create tables for each one.

      csvs-to-sqlite ~/path/to/directory all-my-csvs.db



  You can use the `-s` option to specify a different delimiter. If you want
  to use a tab character you'll need to apply shell escaping like so:

      csvs-to-sqlite my-file.tsv my-file.db -s $'\t'



  Let's say you have a CSV file that looks like this:

      county,precinct,office,district,party,candidate,votes
      Clark,1,President,,REP,John R. Kasich,5
      Clark,2,President,,REP,John R. Kasich,0
      Clark,3,President,,REP,John R. Kasich,7

  ([Real example taken from the Open Elections project](https://github.com/openelections/openelections-data-sd/blob/master/2016/20160607__sd__primary__clark__precinct.csv))

  You can now convert selected columns into separate lookup tables using the new
  `--extract-column` option (shortname: `-c`) - for example:

      csvs-to-sqlite openelections-data-*/*.csv \
          -c county:County:name \
          -c precinct:Precinct:name \
          -c office -c district -c party -c candidate \
          openelections.db

  The format is as follows:

      column_name:optional_table_name:optional_table_value_column_name

  If you just specify the column name e.g. `-c office`, the following table will
  be created:

      CREATE TABLE "office" (
          "id" INTEGER PRIMARY KEY,
          "value" TEXT
      );

  If you specify all three options, e.g. `-c precinct:Precinct:name` the table
  will look like this:

      CREATE TABLE "Precinct" (
          "id" INTEGER PRIMARY KEY,
          "name" TEXT
      );

  The original tables will be created like this:

      CREATE TABLE "ca__primary__san_francisco__precinct" (
          "county" INTEGER,
          "precinct" INTEGER,
          "office" INTEGER,
          "district" INTEGER,
          "party" INTEGER,
          "candidate" INTEGER,
          "votes" INTEGER,
          FOREIGN KEY (county) REFERENCES County(id),
          FOREIGN KEY (party) REFERENCES party(id),
          FOREIGN KEY (precinct) REFERENCES Precinct(id),
          FOREIGN KEY (office) REFERENCES office(id),
          FOREIGN KEY (candidate) REFERENCES candidate(id)
      );

  They will be populated with IDs that reference the new derived tables.



      $ pip install csvs-to-sqlite

  `csvs-to-sqlite` now requires Python 3. If you are running Python 2 you can install the last version to support Python 2:

      $ pip install csvs-to-sqlite==0.9.2



  <!-- [[[cog
  import cog
  from csvs_to_sqlite import cli
  from click.testing import CliRunner
  runner = CliRunner()
  result = runner.invoke(cli.cli, ["--help"])
  help = result.output.replace("Usage: cli", "Usage: csvs-to-sqlite")
  cog.out(
      "```\n{}\n```".format(help)
  )
  ]]] -->
  ```
  Usage: csvs-to-sqlite [OPTIONS] PATHS... DBNAME

    PATHS: paths to individual .csv files or to directories containing .csvs

    DBNAME: name of the SQLite database file to create

  Options:
    -s, --separator TEXT            Field separator in input .csv
    -q, --quoting INTEGER           Control field quoting behavior per csv.QUOTE_*
                                    constants. Use one of QUOTE_MINIMAL (0),
                                    QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or
                                    QUOTE_NONE (3).

    --skip-errors                   Skip lines with too many fields instead of
                                    stopping the import

    --replace-tables                Replace tables if they already exist
    -t, --table TEXT                Table to use (instead of using CSV filename)
    -c, --extract-column TEXT       One or more columns to 'extract' into a
                                    separate lookup table. If you pass a simple
                                    column name that column will be replaced with
                                    integer foreign key references to a new table
                                    of that name. You can customize the name of
                                    the table like so:     state:States:state_name

                                    This will pull unique values from the 'state'
                                    column and use them to populate a new 'States'
                                    table, with an id column primary key and a
                                    state_name column containing the strings from
                                    the original column.

    -d, --date TEXT                 One or more columns to parse into ISO
                                    formatted dates

    -dt, --datetime TEXT            One or more columns to parse into ISO
                                    formatted datetimes

    -df, --datetime-format TEXT     One or more custom date format strings to try
                                    when parsing dates/datetimes

    -pk, --primary-key TEXT         One or more columns to use as the primary key
    -f, --fts TEXT                  One or more columns to use to populate a full-
                                    text index

    -i, --index TEXT                Add index on this column (or a compound index
                                    with -i col1,col2)

    --shape TEXT                    Custom shape for the DB table - format is
                                    csvcol:dbcol(TYPE),...

    --filename-column TEXT          Add a column with this name and populate with
                                    CSV file name

    --fixed-column <TEXT TEXT>...   Populate column with a fixed string
    --fixed-column-int <TEXT INTEGER>...
                                    Populate column with a fixed integer
    --fixed-column-float <TEXT FLOAT>...
                                    Populate column with a fixed float
    --no-index-fks                  Skip adding index to foreign key columns
                                    created using --extract-column (default is to
                                    add them)

    --no-fulltext-fks               Skip adding full-text index on values
                                    extracted using --extract-column (default is
                                    to add them)

    --just-strings                  Import all columns as text strings by default
                                    (and, if specified, still obey --shape,
                                    --date/datetime, and --datetime-format)

    --version                       Show the version and exit.
    --help                          Show this message and exit.

  ```
  <!-- [[[end]]] -->


pkgId: 3139daff92e35b6f5d51f8e3dfc8c74a66cc2e4bd39aa743b4cbdb34ad463a2b
name: python-csvw
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Python library to work with CSVW described tabular data
url: https://github.com/cldf/csvw
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvw-3.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/cldf/csvw/workflows/tests/badge.svg)](https://github.com/cldf/csvw/actions?query=workflow%3Atests)
  [![PyPI](https://img.shields.io/pypi/v/csvw.svg)](https://pypi.org/project/csvw)
  [![Documentation Status](https://readthedocs.org/projects/csvw/badge/?version=latest)](https://csvw.readthedocs.io/en/latest/?badge=latest)


  This package provides
  - a Python API to read and write relational, tabular data according to the [CSV on the Web](https://csvw.org/) specification and
  - commandline tools for reading and validating CSVW data.




  - GitHub: https://github.com/cldf/csvw
  - PyPI: https://pypi.org/project/csvw
  - Issue Tracker: https://github.com/cldf/csvw/issues




  This package runs under Python >=3.8, use pip to install:

  ```bash
  $ pip install csvw
  ```






  Converting CSVW data [to JSON](https://www.w3.org/TR/csv2json/)

  ```shell
  $ csvw2json tests/fixtures/zipped-metadata.json
  {
      "tables": [
          {
              "url": "tests/fixtures/zipped.csv",
              "row": [
                  {
                      "url": "tests/fixtures/zipped.csv#row=2",
                      "rownum": 1,
                      "describes": [
                          {
                              "ID": "abc",
                              "Value": "the value"
                          }
                      ]
                  },
                  {
                      "url": "tests/fixtures/zipped.csv#row=3",
                      "rownum": 2,
                      "describes": [
                          {
                              "ID": "cde",
                              "Value": "another one"
                          }
                      ]
                  }
              ]
          }
      ]
  }
  ```



  Validating CSVW data

  ```shell
  $ csvwvalidate tests/fixtures/zipped-metadata.json
  OK
  ```



  Describing tabular-data files with CSVW metadata

  ```shell
  $ csvwdescribe --delimiter "|" tests/fixtures/frictionless-data.csv
  {
      "@context": "http://www.w3.org/ns/csvw",
      "dc:conformsTo": "data-package",
      "tables": [
          {
              "dialect": {
                  "delimiter": "|"
              },
              "tableSchema": {
                  "columns": [
                      {
                          "datatype": "string",
                          "name": "FK"
                      },
                      {
                          "datatype": "integer",
                          "name": "Year"
                      },
                      {
                          "datatype": "string",
                          "name": "Location name"
                      },
                      {
                          "datatype": "string",
                          "name": "Value"
                      },
                      {
                          "datatype": "string",
                          "name": "binary"
                      },
                      {
                          "datatype": "string",
                          "name": "anyURI"
                      },
                      {
                          "datatype": "string",
                          "name": "email"
                      },
                      {
                          "datatype": "string",
                          "name": "boolean"
                      },
                      {
                          "datatype": {
                              "dc:format": "application/json",
                              "base": "json"
                          },
                          "name": "array"
                      },
                      {
                          "datatype": {
                              "dc:format": "application/json",
                              "base": "json"
                          },
                          "name": "geojson"
                      }
                  ]
              },
              "url": "tests/fixtures/frictionless-data.csv"
          }
      ]
  }
  ```




  Find the Python API documentation at [csvw.readthedocs.io](https://csvw.readthedocs.io/en/latest/).

  A quick example for using `csvw` from Python code:

  ```python
  import json
  from csvw import CSVW
  data = CSVW('https://raw.githubusercontent.com/cldf/csvw/master/tests/fixtures/test.tsv')
  print(json.dumps(data.to_json(minimal=True), indent=4))
  [
      {
          "province": "Hello",
          "territory": "world",
          "precinct": "1"
      }
  ]
  ```




  - We read **all** data which is specified as UTF-8 encoded using the
    [`utf-8-sig` codecs](https://docs.python.org/3/library/codecs.html#module-encodings.utf_8_sig).
    Thus, if such data starts with `U+FEFF` this will be interpreted as [BOM](https://en.wikipedia.org/wiki/Byte_order_mark)
    and skipped.
  - Low level CSV parsing is delegated to the `csv` module in Python's standard library. Thus, if a `commentPrefix`
    is specified in a `Dialect` instance, this will lead to skipping rows where the first value starts
    with `commentPrefix`, **even if the value was quoted**.
  - Also, cell content containing `escapechar` may not be round-tripped as expected (when specifying
    `escapechar` or a `csvw.Dialect` with `quoteChar` but `doubleQuote==False`),
    when minimal quoting is specified. This is due to inconsistent `csv` behaviour
    across Python versions (see https://bugs.python.org/issue44861).




  While we use the CSVW specification as guideline, this package does not (and
  probably never will) implement the full extent of this spec.

  - When CSV files with a header are read, columns are not matched in order with
    column descriptions in the `tableSchema`, but instead are matched based on the
    CSV column header and the column descriptions' `name` and `titles` atributes.
    This allows for more flexibility, because columns in the CSV file may be
    re-ordered without invalidating the metadata. A stricter matching can be forced
    by specifying `"header": false` and `"skipRows": 1` in the table's dialect
    description.

  However, `csvw.CSVW` works correctly for
  - 269 out of 270 [JSON tests](https://w3c.github.io/csvw/tests/#manifest-json),
  - 280 out of 282 [validation tests](https://w3c.github.io/csvw/tests/#manifest-validation),
  - 10 out of 18 [non-normative tests](https://w3c.github.io/csvw/tests/#manifest-nonnorm)

  from the [CSVW Test suites](https://w3c.github.io/csvw/tests/).




  A CSVW-described dataset is basically equivalent to a Frictionless DataPackage where all
  [Data Resources](https://specs.frictionlessdata.io/data-resource/) are [Tabular Data](https://specs.frictionlessdata.io/tabular-data-resource/).
  Thus, the `csvw` package provides some conversion functionality. To
  "read CSVW data from a Data Package", there's the `csvw.TableGroup.from_frictionless_datapackage` method:
  ```python
  from csvw import TableGroup
  tg = TableGroup.from_frictionless_datapackage('PATH/TO/datapackage.json')
  ```
  To convert the metadata, the `TableGroup` can then be serialzed:
  ```python
  tg.to_file('csvw-metadata.json')
  ```

  Note that the CSVW metadata file must be written to the Data Package's directory
  to make sure relative paths to data resources work.

  This functionality - together with the schema inference capabilities
  of [`frictionless describe`](https://framework.frictionlessdata.io/docs/guides/describing-data/) - provides
  a convenient way to bootstrap CSVW metadata for a set of "raw" CSV
  files, implemented in the [`csvwdescribe` command described above](#csvwdescribe).




  - https://www.w3.org/2013/csvw/wiki/Main_Page
  - https://csvw.org
  - https://github.com/CLARIAH/COW
  - https://github.com/CLARIAH/ruminator
  - https://github.com/bloomberg/pycsvw
  - https://specs.frictionlessdata.io/table-schema/
  - https://github.com/theodi/csvlint.rb
  - https://github.com/ruby-rdf/rdf-tabular
  - https://github.com/rdf-ext/rdf-parser-csvw
  - https://github.com/Robsteranium/csvwr




  This package is distributed under the [Apache 2.0 license](https://opensource.org/licenses/Apache-2.0).


pkgId: d0e6cba5c5f4f54053e0c9f7f5f8b721be7277d0ad614e5cf450baf491f9d212
name: python-csvwlib
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Python implementation of CSV on the Web
url: https://github.com/DerwenAI/csvwlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-csvwlib-0.3.2-1.src.rpm
checksum_type: sha256
description:
  `csvwlib` is a Python implementation of the W3C
  [CSV on the Web](http://w3c.github.io/csvw/) recommendations.

  This enables converting tabular data, and optionally its associated
  metadata, to a semantic graph in RDF or JSON-LD format.

  Tabular data includes CSV files, TSV files, and upstream may be
  coming from spreadsheets, RDBMS export, etc.

  Requires Python 3.6 or later.




  ```
  pip install csvwlib
  ```




  The library exposes one class - `CSVWConverter` which has methods `to_json()` and `to_rdf()`

  Both of these methods have similar API, and require 3+ parameters:

    * `csv_url` - URL of a CSV file; default `None`
    * `metadata_url` - optional URL of a metadata file; default `None`
    * `mode` - conversion mode; default `standard`, or `minimal`

  The are three ways of starting the conversion process:

    * pass only `csv_url` - corresponding metadata will be looked up based on `csv_url` as described in [Locating Metadata](https://www.w3.org/TR/2015/REC-tabular-data-model-20151217/#locating-metadata)

    * pass both `csv_url` and `metadata_url` - metadata by user will be used. If `url` field is set in metadata, the CSV file will be retrieved from that location which can cause, that passed `csv_url` will be ignored

    * pass only `metadata_url` - associated CSV files will be retrieved based on metadata `url` field


  You can also specify the conversion mode - `standard` or `minimal`, the default is `standard`.
  From the [W3C documentation](https://www.w3.org/TR/2015/REC-csv2rdf-20151217/):

  > **Standard** mode conversion frames the information gleaned from the cells of the tabular data with details of the rows, tables, and a group of tables within which that information is provided.
  > **Minimal** mode conversion includes only the information gleaned from the cells of the tabular data.

  After conversion to JSON, you receive a `dict` object, when converting to RDF it is more complex.
  If you pass `format` parameter, graph will be serialized to this format and returned as string.
  From the `rdflib` docs:

  > Format support can be extended with plugins, but "xml", "n3", "turtle", "nt", "pretty-xml", "trix", "trig" and "nquads" are built in.

  If you don't specify the format, you will receive a `rdflib.Graph` object.




  Example data+metadata files can be found at
  <http://w3c.github.io/csvw/tests/>

  Starting with CSV:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_rdf("http://w3c.github.io/csvw/tests/test001.csv", format="ttl")
  ```

  Minimal mode:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_rdf("http://w3c.github.io/csvw/tests/tree-ops.csv", mode="minimal", format="ttl")
  ```

  Starting with metadata only:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_rdf(metadata_url="http://w3c.github.io/csvw/tests/test188-metadata.json", format="ttl")
  ```

  Both CSV and metadata URL specified:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_rdf("http://w3c.github.io/csvw/tests/tree-ops.csv", "http://w3c.github.io/csvw/tests/tree-ops.csv", format="ttl")
  ```

  Starting with metadata:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_json("http://w3c.github.io/csvw/tests/countries.json")
  ```

  Starting with CSV:
  ```python
  from csvwlib import CSVWConverter

  CSVWConverter.to_json("http://w3c.github.io/csvw/tests/test001.csv")
  ```




  Authored by [@Aleksander-Drozd](https://github.com/Aleksander-Drozd)

  Maintained by [@DerwenAI](https://github.com/DerwenAI)


pkgId: 497b4797982b24d23e073f548df635ff68d712d6b69e68d380d504d7c215ae41
name: python-cszp
arch: src
version: 5.4.0.8
epoch: 0
release: 1
summary: cszp Easy soccer execution program
url: https://github.com/kumitatepazuru/cszp
rpm_license: GNU GENERAL PUBLIC LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cszp-5.4.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/kumitatepazuru/cszp.svg?branch=master)](https://travis-ci.org/kumitatepazuru/cszp)

  ![Logo](https://raw.githubusercontent.com/kumitatepazuru/cszp/master/logo.png)

  [日本語ページはこちら](https://github.com/kumitatepazuru/cszp/blob/master/README_jp.md)




  Operation check OS
  - ubuntu 16.04LTS
  - ubuntu server 16.04LTS
  - debian 10.1
  - zorinos 15.2
  - ubuntu 18.04LTS
  - ubuntu 20.04LTS



  ```
  pip3 install cszp
  ```


pkgId: 3ec67560a5daa35733bbbc07e9816851afd5e85f470ad88bf849aee5b4eb61a2
name: python-ctREFPROP
arch: src
version: 0.10.3
epoch: 0
release: 1
summary: A ctypes wrapper for NIST REFPROP library
url: https://pypi.org/project/ctREFPROP/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctREFPROP-0.10.3-1.src.rpm
checksum_type: sha256
rpm_license:
  # NIST Software Licensing Statement  NIST-developed software is provided by NIST as a public service. You may use, copy, and distribute copies of the software in any medium, provided that you keep intact this entire notice. You may improve, modify, and create derivative works of the software or any portion of the software, and you may copy and distribute such modifications or works. Modified works should carry a notice stating that you changed the software and should note the date and nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the source of the software.  NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT, OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE.  You are solely responsible for determining the appropriateness of using and distributing the software and you assume all risks associated with its use, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of operation. This software is not intended to be used in any situation where a failure could cause risk of injury or damage to property. The software developed by NIST employees is not subject to copyright protection within the United States.


pkgId: 4137e9db9e295500e74c73ceb5f61306179b096b8784a94d74e0f68da45e4fba
name: python-ctadata
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ctadata/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctadata-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a prototype development only for Swiss CTA DC. Please report bugs here, and for any details please inquire the CTAO CH DC management.



  CTA data are/will be stored at CTAO-CH data center at CSCS.
  These data should be accessible for selected external users.
  In addition, these files should be available within interactive analysis platform at CSCS.
  This client presents an API access to these services and data.


  ```bash
  $ pip install 'ctadata>=0.2.6'
  ```



  From within CTA CSCS JupyterHub platform, selected authorized users are able to access the "data download service", like so:

  ```python
  import ctadata

  for url in ctadata.list_dir("cta/DL1/20241114/v0.1/"):
      if 'datacheck' not in url and '.0100' in url and '11111' in url:
          print("stored", ctadata.fetch_and_save_file(url)/1024/1024, "Mb")
          print("found keys", h5py.File(url.split("/")[-1]).keys())
  ```

  To download a file:

  ```python
  ctadata.fetch_and_save_file_or_dir("lst/some-data-dir", recursive=True)
  ```

  or, in bash and recursively:

  ```bash
  ctadata get --recursive lst/some-data-dir
  ```



  To upload a file:

  ```python
  ctadata.upload_file("latest", "filelists/latest-file-list")
  ```

  The result is:

  ```json
  {
      "path": "lst/users/volodymyr_savchenko_epfl_ch/filelists/latest-file-list",
      "status": "uploaded",
      "total_written": 60098730
  }
  ```

  Note that for every user, the file is uploaded to their own directory constructed from the user name. The path specified is relative to this directory. If you need to move the files to common directories, please as support.  But you likely want to just share returned path to be used as so:

  ```python
  ctadata.fetch_and_save_file("lst/users/volodymyr_savchenko_epfl_ch/filelists/latest-file-list")
  ```

  You can also use command line interface to do this:

  ```bash
  $ cta-data put latest-file-list latest-file-list-bla-bla
  ```

  **Beware that all the files written are accessible to all CTAO members and all platform users.**



  You need to get yourself a jupyterhub token, it will be used to authenticate to the download service.

  If you are in the session, navigate to the hub control panel this way:

  ![image](https://user-images.githubusercontent.com/3909535/227050172-35318c23-c138-40cb-b6ce-d2f6e780fa06.png)

  Request a token:

  ![image](https://user-images.githubusercontent.com/3909535/227050281-2b012c15-ab84-4d75-a961-85057440fcf4.png)

  The rest is similar to the previous case:

  ```python
  import os
  os.environ["CTADS_URL"] = "DATA-DISTRIBUTING-JUPYTERHUB/services/downloadservice/"
  os.environ["JUPYTERHUB_API_TOKEN"] = "INSERT-YOUR-TOKEN-HERE"

  for url in ctadata.list_dir("cta/DL1/20241114/v0.1"):
      if 'datacheck' not in url and '.0100' in url and '11111' in url:
          print("stored", ctadata.fetch_and_save_file(url)/1024/1024, "Mb")
          print("found keys", h5py.File(url.split("/")[-1]).keys())
  ```



  In order to make use of bare WebDAV interface of the storage, `ctadata` also provides a configured `webdav4` client (see [webdav4](https://github.com/skshetry/webdav4) for documentation).

  ```python
  client = ctadata.webdav4_client()
  client.ls("/")
  client.uploadFile("example.txt", "remote/example.txt")
  ```

  Please see [WebDAV4 documenation](https://skshetry.github.io/webdav4/) for details on it's wide range of features.



  In order to make use of your own grid certificate to access CTA-CSCS storage from within CTA interactive platform it is necessary to upload you short-term proxy certificate to the platform. `cta-data` provides an easy way to do this:

  This tools also offers a way to upload your own time limited certificate to access the background webdav server.

  ```python
  import ctadata
  ctadata.upload_certificate('yourcertificate.crt')
  ```

  Note that if you do not upload your own certificate, you can ask to make use of a shared robot certificate used for data syncing.


pkgId: bf49427dbea77478209131f3602008cd2d681a914c55a0978e7347ad81f564f0
name: python-ctapipe-io-lst
arch: src
version: 0.25.1
epoch: 0
release: 1
summary: ctapipe plugin for reading LST prototype files
url: https://pypi.org/project/ctapipe-io-lst/
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctapipe-io-lst-0.25.1-1.src.rpm
checksum_type: sha256
description:
  EventSource Plugin for ctapipe, able to read LST zfits files
  and calibration them to R1 as needed for ctapipe tools.

  Since version 0.19, `ctapipe_io_lst` is on conda-forge,
  which is the easiest way to install it, since the `protozfits`
  dependency is offered pre-compiled for Linux and mac OS (including arm64).

  To install into an exisiting environtment, just do:
  ```

  $ mamba install -c conda-forge ctapipe_io_lst
  ```

  For development, create a new environment and run the development install:
  ```
  conda env create -n lstenv -f environment.yml
  conda activate lstenv
  pip install -e .
  ```

  `ctapipe_io_lst` is also on PyPI, but note that the `protozfits`
  dependency only has wheels for Linux, so you'd need to compile
  from source on mac OS.



  To run the tests, a set of non-public files is needed.
  If you are a member of CTA, ask one of the project maintainers for the credentials
  and then run

  ```
  ./download_test_data.sh
  ```


pkgId: 3d6bdafee6f35d101cbc88357e2f06217ce2694b5db8b7cebaa48b3b990e330f
name: python-ctbl-tools
arch: src
version: 0.1.7
epoch: 0
release: 1
url: https://pypi.org/project/ctbl-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctbl-tools-0.1.7-1.src.rpm
checksum_type: sha256
summary:
  A set of helpers classes for daily tasks: a reusable config file, a process helper, and a git interface.

description:
  A package with miscelaneous classes meant to help at coding console helpers. Currently there are three classes:

  1. **config**: it implements a config file that saves itself. It is a specialization of [configparser](https://docs.python.org/3/library/configparser.html).
  2. **process**: it runs external processes, it saves the return code, and it helps (a little bit) to parse the standard output (or the standard error).
  3. **git**: a simple interface for git commands.



  It implements a config file that saves itself.

  The idea is: we want to use a config file for an application, which is a simple text file that contains pairs of values, in a similar fashion to an INI file. If the file exists, it is used; if it doesn't, it is created. We use [configparser](https://docs.python.org/3/library/configparser.html) for this.

  An example:

  ```python
  from ctbl_tools.config import config

  cfg = config(initpath = '~/somewhere/blabla.ini')
  cfg.create_section('my_configuration')
  cfg.set('my_configuration', 'x', 1)
  cfg.set('my_configuration', 'y', '2')
  ```

  When the program above ends, it will save all created configuration to the file ~/somewhere/blabla.ini.



  It runs an external program, and it stores the return code and both the standard output and standard error.

  You first create an object of this type:
  ```python
  p = process()
  ```

  Then run a command:
  ```python
  p.run("whoami")
  ```

  Immediately after you gain access to the return code, stdout and stderr:
  ```python
  print(p.returncode)
  for line in p.stdout:
    print(line)
  ```

  You may check if return code was 0 (i.e., all good) by checking `p.is_ok()` to be true. You may also check whether there is any stdout or any stderr with `p.is_there_stdout()` and with `p.is_there_stderr()`, respectively.

  Finally you may extract information out of stdout by using `extract()`. This method receives a regular expression and a boolean that is true by default (meaning that you want to inspect stdout; if false it will inspect stderr instead). The method will look for all matches in each line of stdout and store them in a list. The list stores as many elements as lines stdout has, and each element is a list of all matches within the corresponding line.



  It provides a simple programmatical interface to git.

  First, you create a git object by providing a local path to a repo:

  ```python
  from ctbl_tools.git import git

  x = git("~/Dev/my_repo")
  ```
  The previous will fail if provided path is not a git repo.

  Then you may either get the remote urls with `x.get_remote()`, or a get the status of the working tree by invoking `x.get_status()`.

  You may also do a commit with a list of files with `x.commit(list-of-files)`, or do a push (`x.git_push('my-commit-message')`) or a pull (`x.git_pull()`).

  This package also includes two auxiliary functions:

  * `git_clone(url:str, path:str)`: It clones `url` into `path`.
  * `is_git_url(url:str)`: It checks whether `url` is a valid git url.


pkgId: c1c0bc09c44ef79a58a298690e793e1a7dbc264b7028eb722b0ff2d654da5221
name: python-ctcsound7
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Python bindings to the Csound API, supporting all versions of csound higher or equal to 6.18
url: https://github.com/csound-plugins/ctcsound7
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctcsound7-0.6.1-1.src.rpm
checksum_type: sha256
rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999  Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  (This is the first released version of the Lesser GPL.  It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.)  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it.  You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.  When we speak of free software, we are referring to freedom of use, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.  To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights.  These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.  For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you.  You must make sure that they, too, receive or can get the source code.  If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it.  And you must show them these terms so they know their rights.  We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.  To protect each distributor, we want to make it very clear that there is no warranty for the free library.  Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.  Finally, software patents pose a constant threat to the existence of any free program.  We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder.  Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.  Most GNU software, including some libraries, is covered by the ordinary GNU General Public License.  This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License.  We use this license for certain libraries in order to permit linking those libraries into non-free programs.  When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library.  The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom.  The Lesser General Public License permits more lax criteria for linking other code with the library.  We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License.  It also provides other free software developers Less of an advantage over competing non-free programs.  These disadvantages are the reason we use the ordinary General Public License for many libraries.  However, the Lesser license provides advantages in certain special circumstances.  For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard.  To achieve this, non-free programs must be allowed to use the library.  A more frequent case is that a free library does the same job as widely used non-free libraries.  In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.  In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software.  For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.  Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.  The precise terms and conditions for copying, distribution and modification follow.  Pay close attention to the difference between a "work based on the library" and a "work that uses the library".  The former contains code derived from the library, whereas the latter must be combined with the library in order to run.  GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you".  A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.  The "Library", below, refers to any such software library or work which has been distributed under these terms.  A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  "Source code" for a work means the preferred form of the work for making modifications to it.  For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it).  Whether that is true depends on what the Library does and what the program that uses the Library does.  1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) The modified work must itself be a software library.  b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.  c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.  d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.  (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application.  Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.  In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library.  To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License.  (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.)  Do not make any other change in these notices.  Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.  This option is useful when you wish to copy part of the code of the Library into a program that is not a library.  4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.  If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.  5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library".  Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.  However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library".  The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.  When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library.  The threshold for this to be true is not precisely defined by law.  If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work.  (Executables containing this object code plus portions of the Library will still fall under Section 6.)  Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.  6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.  You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License.  You must supply a copy of this License.  If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License.  Also, you must do one of these things:  a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library.  (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)  b) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.  c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.  d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.  e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.  For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it.  However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system.  Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.  7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities.  This must be distributed under the terms of the Sections above.  b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License.  However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  9. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Library or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.  10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.  11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all.  For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.  14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Libraries  If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change.  You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).  To apply these terms, attach the following notices to the library.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  {description} Copyright (C) {year} {fullname}  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker.  {signature of Ty Coon}, 1 April 1990 Ty Coon, President of Vice  That's all there is to it!


pkgId: 62282dd2e60876587f61e4665f2c8c53bfcb9c134e4d845c23403a0a6eb275b7
name: python-ctdfjorder
arch: src
version: 0.8.91
epoch: 0
release: 1
summary: A package for processing and analyzing CTD data.
url: https://github.com/nikothomas/ctdfjorder
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctdfjorder-0.8.91-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13293665.svg#3)](https://doi.org/10.5281/zenodo.13293665)
  ![Tests](https://github.com/nikothomas/ctdfjorder/actions/workflows/tests.yml/badge.svg?branch=main)
  ![badge](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/nikothomas/5ceb7e714da5151b751f668c4cc49013/raw/answer.json)
  [![PyPI version](https://badge.fury.io/py/ctdfjorder.svg#4)](https://badge.fury.io/py/ctdfjorder)

  <p style=text-align:center;>
    <img src="https://raw.githubusercontent.com/nikothomas/ctdfjorder/main/logo.png" alt="CTDFjorder Logo"/>
  </p>

  CTDFjorder is a Python package for processing and analyzing CTD (Conductivity, Temperature, Depth) data.
  Documentation: [Read the docs](https://ctdfjorder.readthedocs.io/en/latest)

  - [<code>⭐ Features</code>](#-features)
  - [<code>📦 Installation</code>](#-installation)
  - [<code>🚀 Usage</code>](#-usage)
  - [<code>⚠️ Issues</code>](#-issues)
  - [<code>📝 License</code>](#-license)
  - [<code>📑 Citing CTDFjorder</code>](#-license)
  - [<code>📢 Acknowledgments</code>](#-acknowledgments)


  - Read RBR (.rsk) and SonTek Castaway (.csv) files and extract CTD data
  - Process CTD data, including removing non-positive samples and cleaning data
  - Calculate derived quantities such as absolute salinity, density, and potential density
  - Determine mixed layer depth (MLD) using different methods
  - Generate plots for visualizing CTD profiles and derived quantities
  - Command-line interface (CLI) for easy processing and merging of CTD data files


  It's recommended that you create a new environment just for CTDFjorder. This can be done in conda with the following
  command.
  ```shell
  conda create --name ctdfjorder python=3.12
  conda activate ctdfjorder
  ```
  To install ctdfjorder you can use pip:
  ```shell
  pip install ctdfjorder
  ```


  CTDFjorder provides a command-line interface (CLI) for processing and analyzing CTD data in addition to serving
  as a python library. A tutorial has been setup [here](https://ctdfjorder.readthedocs.io/en/latest/Getting%20Started.html)
  for running the CLI.


  If you encounter an issue while running or using CTDFjorder, please submit a report on the
  [Issues](https://github.com/nikothomas/ctdfjorder/issues) page. This is the fastest way to get your problem resolved.


  CTDFjorder is released under the MIT License.


  Citation information for CTDFjorder can be found here [zenodo.13293665](https://dx.doi.org10/zenodo.13293665>).


  CTDFjorder was developed for the [Fjord Phyto](https://fjordphyto.ucsd.edu) project. The [GSW-python](https://github.com/TEOS-10/GSW-Python) library was used for certain dervied calculations.


  McDougall, T. J., & Barker, P. M. (2011). Getting started with TEOS-10 and the Gibbs Seawater (GSW) Oceanographic Toolbox. SCOR/IAPSO WG127.

  Pan, B.J.; Vernet, M.; Reynolds, R.A.; Mitchell, B.G.: The optical and biological properties of glacial meltwater in an Antarctic fjord. PLOS ONE 14(2): e0211107 (2019). https://doi.org/10.1371/journal.pone.0211107


pkgId: 82ad284f775218a1298ea08cb6a79ae385a9fd9821824e125b3fa2a3c9a97f01
name: python-ctea
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: TEA Decryption
url: https://github.com/Rin-Wood/ctea
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctea-1.0.1-1.src.rpm
checksum_type: sha256
description:
  `ctea` is a Python package for decrypting data, using a custom TEA decryption algorithm implemented in C.



  - Provides efficient TEA decryption functionality, based on C implementation.
  - Supports Python 3.6+



  Install the latest version of `ctea` from PyPI:

  ```bash
  pip install ctea
  ```


  Here's how to use `ctea` for decryption:

  ```python
  import ctea

  dec = ctea.decrypt(data)


pkgId: de3f0b52a5fe30a0de127f9411772b7ffb23adba1b10480e34d0bdaea078b78a
name: python-ctk
arch: src
version: 0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ctk/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctk-0.1-1.src.rpm
checksum_type: sha256
description:
  ctk is a user-friendly wrapper around tkinter to help users quickly create GUIs without having to worry about overlapping cells via the grid framework. All normal tk calls are available, though some helper functions are added to make development easier.


pkgId: e8ae5a0e0d4c153894255b7d37954afee341f868fad56600cda0da0cebdda9b8
name: python-ctlepy
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Python package for ctle
url: https://github.com/Cooolrik/ctle
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctlepy-1.5.0-1.src.rpm
checksum_type: sha256
description:
  C++ Template Library Extension classes - Extension classes for Windows and Linux STL


  Copyright (c) 2022-2024 Ulrik Lindahl
  Licensed under the MIT license https://github.com/Cooolrik/ctle/blob/main/LICENSE

  MIT License

  Copyright (c) 2022 Ulrik Lindahl

  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: 06b886b1a146d2d9fd97db8675a47804f2eb99a8efc2b97bd67a7b303561904d
name: python-ctm-python-client
arch: src
version: 2.3.6
epoch: 0
release: 1
summary: Python Workflows for Control-M
url: https://pypi.org/project/ctm-python-client/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctm-python-client-2.3.6-1.src.rpm
checksum_type: sha256
description:
  Control-M Python Client is a python library to programmatically design, schedule and run your Control-M workflows. The design of the Control-M Python Client is oriented towards data scientists and developers who prefer a more programmatic approach to workflow orchestration.



  The best way to get familiar is to check the [Documentation](https://controlm.github.io/ctm-python-client/). Start with the [Tutorials](https://controlm.github.io/ctm-python-client/tutorials.html) to get familiar with the syntax.

  You do not need to have an in-depth knowledge of Control-M, but some familiarity with Control-M will help you understand the different job types and syntax offered by Control-M Python Client.



  Control-M Python client requires [Python](https://www.python.org/downloads/) version 3.7 or higher.

  We recommend to install Control-M Python Client in a [virtual environment](https://docs.python.org/3/library/venv.html).

  For Linux:
  ```
  python -m venv venv
  source venv/bin/activate
  ```

  For Windows:
  ```
  python -m venv venv
  venv\Scripts\activate
  ```


  You will need pip and git installed on your system before you run this command.
  ```
  pip install ctm-python-client
  ```



  ```
  git clone https://github.com/controlm/ctm-python-client.git
  pip install ctm-python-client
  ```



  See [Contributing](https://github.com/controlm/ctm-python-client/blob/main/CONTRIBUTING.md)



  - [Control-M Documentation](https://docs.bmc.com/docs/display/workloadautomation/Control-M+Workload+Automation+Documentation)
  - [Helix Control-M Documentation](https://documents.bmc.com/supportu/controlm-saas/en-US/Documentation/home.htm)
  - [Automation API Documentation](https://docs.bmc.com/docs/display/public/workloadautomation/Control-M+Automation+API+-+Getting+Started+Guide)
  - [Automation API with Helix Control-M Documentation](https://docs.bmc.com/docs/display/ctmSaaSAPI/Control-M+SaaS+Automation+API+Home)
  - [Provisioning an agent with Automation API](https://docs.bmc.com/docs/automation-api/monthly/provision-service-1040174602.html#Provisionservice-provisionFresh)
  - [Application Integrator](https://documents.bmc.com/supportu/9.0.20/etc/ai/help/en-US/Web_Help/index.htm#69319.htm)



  See [License](https://github.com/controlm/ctm-python-client/blob/main/LICENSE)


pkgId: 8ab2a037c3ea1b0303e509b5d70d359281d734f93cfdff61761433f1318d0cdc
name: python-cto-ai
arch: src
version: 2.3.3
epoch: 0
release: 1
summary: SDK for The Ops Platform
url: https://github.com/cto-ai/sdk-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cto-ai-2.3.3-1.src.rpm
checksum_type: sha256
description:
  ![](https://cto.ai/static/sdk-banner.png)



  This is the Python version of The Ops Platform SDK. In
  conjunction with our Docker base images, it allows the development of
  automations with rich user interfaces, that run in both the local
  terminal and in Slack. Other than the Ops Platform itself, this SDK
  depends on:

  - Python 3.6+
  - The `requests` library, version 2+



  This SDK is designed to work in conjunction with The Ops
  Platform. Please see <https://cto.ai/platform> for more details.

  To build and publish Ops to The Ops Platform, you will need to use
  The Ops CLI. Find installation instructions and reference
  documentation at <https://cto.ai/docs>.


pkgId: 7d50f1430ecbf9e33af185fce2425eaa8ef63b4ac58c7e6b523336c5381b6307
name: python-ctrl-benchmark
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: The Continual Transfer Learning Benchmark
url: https://github.com/facebookresearch/CTrLBenchmark
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctrl-benchmark-0.0.4-1.src.rpm
checksum_type: sha256
description:
  The CTrL benchmark aims to help research by studying the transfer behaviour of different models in the Lifelong Learning context.

  For a quick presentation of the benchmark, please check out [this blog post](https://ai.facebook.com/blog/ctrl-and-mntdp-a-new-open-source-benchmark-and-model-for-continual-learning/).

  For more details, the paper is available on [arxiv](https://arxiv.org/abs/2012.12631).



  The `TaskGenerator` class is at the center of the implementation of the CTrL Benchmark.
  It gives access to a high-level API allowing to seamlessly generate a wide variety of streams with a loose coupling between the different components such as the underlying dataset(s), the strategy to generate the tasks (split, incremental, mixture of datasets, ...) and the processing to apply to each task.

  The 3 main components of a `Task Generator` are:
  - A pool of concepts to select from to generate the tasks. It can be a few classes, a full dataset or even a mixture of datasets.
  - A pool of transformation that can be modified or combined to apply specific processing to the data for each task.
  - A Strategy, describing how to combine the conecpts and trasnformation over time to generate an actual stream.

  Each of these components can be created by hand or using our automatic `TaskGenerator` creation tool using yaml configuration files.

  For examples simply executing
  ```python
  import ctrl
  task_gen = ctrl.get_stream('s_minus')
  ```
  will return the corresponding task generator that be used either directy to generate tasks on the fly:
  ```python
  t1 = task_gen.add_task()
  t2 = task_gen.add_task()
  t3 = task_gen.add_task()
  ...
  ```

  or as an iterator:
  ```python
  for t in task_gen:
      print(t)
  ```


  In the current version, only the streams of the CTrL benchmark are directly available, they can be obtained by passing the following `name` arguments in `ctrl.get_stream`:
  - S<sup>+</sup>: `"s_plus"`
  - S<sup>-</sup>: `"s_minus"`
  - S<sup>in</sup>: `"s_in"`
  - S<sup>out</sup>: `"s_out"`
  - S<sup>pl</sup>: `"s_pl"`
  - S<sup>long</sup>: `"s_long"`


  More documentation and details on the internal components will be progressively added.

  See the CONTRIBUTING file for how to help out.


  See the LICENSE file.


pkgId: 675b43f8d5385bf0c3994703dbe6b6c96e73c57ebb98d79e20e58f05b19d3a0c
name: python-ctrl4ai
arch: src
version: 1.0.24
epoch: 0
release: 1
summary: A helper package for Machine Learning and Deep Learning Algorithms
url: https://github.com/vkreat-tech/ctrl4ai
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctrl4ai-1.0.24-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](http://pepy.tech/badge/ctrl4ai)](http://pepy.tech/project/ctrl4ai)



  For documentation, please read [HELP.md](https://github.com/vkreat-tech/ctrl4ai/blob/master/HELP.md)

  For demo on usage, please check [README.ipynb](https://github.com/vkreat-tech/ctrl4ai/blob/master/README.ipynb)




  - Open Source Package with emphasis on data preprocessing so far.
  - Self intelligent methods that can be employed at the levels of abstraction or customization.
  - The flow of auto-preprocessing is orchestrated compatible to the learning type.
  - Parameter tuning allows users to transform the data precisely to their specifications.
  - Developed computations for inspecting the data to discover its type, distribution, correlation etc. which are handled in the background.


  Ctrl4AI requires:
  * Python 3 (tested under Python 3.8)


  The easiest way to install the latest release version of Ctrl4AI is via ```pip```:
  ```bash
  pip install ctrl4ai
  ```
  In case you get ```ERROR: Could not install packages due to an EnvironmentError```, try using
  ```bash
  pip install ctrl4ai --user
  ```
  Check for the latest available version in [Ctrl4AI](https://pypi.org/project/ctrl4ai/)


  Import any module from the package through the following method:
  ```bash
  from ctrl4ai import prepdata
  ```
  ```bash
  from ctrl4ai import automl
  ```


  Understand what each function does by using ```help()```:
  ```bash
  help(automl.preprocess)
  ```


  - Added features to transform ordinal values (from string to integers)


  - Model specific pre-processing
  - Prepare dataset for bagging Algorithms
  - Preprocessing for Text,Image,Audio,Video Analytics


  - All functions in ```ctrl4ai.preprocessing``` are depreciated by the end of 2022 based on the prior notice. Please plan to switch to the same functions in ```ctrl4ai.prepdata``` if you're still using it.



  - Project Owner: [Shaji James](https://www.linkedin.com/in/shaji-james/)
  - Collaborators: [Charu](https://www.linkedin.com/in/charunethragiri/), [Selva](https://www.linkedin.com/in/selva-prasanth-274b66166/)


pkgId: 1b09ebdf4d69af2973393de24856a72151dc8f2e650af2c257a53956beb57d7b
name: python-ctrlplane
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A client library for accessing Ctrlplane API
url: https://pypi.org/project/ctrlplane/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctrlplane-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A client library for accessing Ctrlplane API



  First, create a client:

  ```python
  from ctrlplane import Client

  client = Client(base_url="https://api.example.com")
  ```

  If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:

  ```python
  from ctrlplane import AuthenticatedClient

  client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
  ```

  Now call your endpoint and use your models:

  ```python
  from ctrlplane.models import MyDataModel
  from ctrlplane.api.my_tag import get_my_data_model
  from ctrlplane.types import Response

  with client as client:
      my_data: MyDataModel = get_my_data_model.sync(client=client)
      
      response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
  ```

  Or do the same thing with an async version:

  ```python
  from ctrlplane.models import MyDataModel
  from ctrlplane.api.my_tag import get_my_data_model
  from ctrlplane.types import Response

  async with client as client:
      my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
      response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
  ```

  By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl="/path/to/certificate_bundle.pem",
  )
  ```

  You can also disable certificate validation altogether, but beware that **this is a security risk**.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl=False
  )
  ```

  Things to know:

  1. Every path/method combo becomes a Python module with four functions:

     1. `sync`: Blocking request that returns parsed data (if successful) or `None`
     1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
     1. `asyncio`: Like `sync` but async instead of blocking
     1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking

  1. All path/query params, and bodies become method arguments.
  1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
  1. Any endpoint which did not have a tag will be in `ctrlplane.api.default`



  There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):

  ```python
  from ctrlplane import Client

  def log_request(request):
      print(f"Request event hook: {request.method} {request.url} - Waiting for response")

  def log_response(response):
      request = response.request
      print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

  client = Client(
      base_url="https://api.example.com",
      httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
  )


  ```

  You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

  ```python
  import httpx
  from ctrlplane import Client

  client = Client(
      base_url="https://api.example.com",
  )

  client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
  ```



  This project uses [Poetry](https://python-poetry.org/) to manage dependencies and packaging. Here are the basics:

  1. Update the metadata in pyproject.toml (e.g. authors, version)
  1. If you're using a private repository, configure it with Poetry
     1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
     1. `poetry config http-basic.<your-repository-name> <username> <password>`
  1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`

  If you want to install this client into another project without publishing it (e.g. for development) then:

  1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
  1. If that project is not using Poetry:
     1. Build a wheel with `poetry build -f wheel`
     1. Install that wheel from the other project `pip install <path-to-wheel>`



  ```bash
  openapi-python-client generate \
      --output-path . \
      --url https://raw.githubusercontent.com/ctrlplanedev/ctrlplane/refs/heads/main/openapi.v1.json
  ```


pkgId: 12c97a2f0ed2e24b4e5086cb8ae1f1c027f2147cdef68be2dc4b3e6b3daaa49d
name: python-ctrlutils
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Python robot control utils
url: https://github.com/tmigimatsu/ctrl-utils.git
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctrlutils-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Builds](https://github.com/tmigimatsu/ctrl-utils/actions/workflows/builds.yaml/badge.svg)](https://github.com/tmigimatsu/ctrl-utils/actions/workflows/builds.yaml)
  [![Docs](https://github.com/tmigimatsu/ctrl-utils/actions/workflows/docs.yaml/badge.svg)](https://github.com/tmigimatsu/ctrl-utils/actions/workflows/docs.yaml)



  `ctrl-utils` is a C++/Python utilities library for robot control.

  See the documentation for `ctrl-utils`
  [here](https://tmigimatsu.github.io/ctrl-utils/).



  This library is written in C++ with Python bindings automatically generated with
  [pybind11](https://github.com/pybind/pybind11). It has been tested on
  Ubuntu 18.04, Ubuntu 20.04, and macOS 10.15 Catalina.

  Compilation requirements:
  - `cmake >= 3.11`
  - C++17 support (`gcc >= 7`, `clang >= 7`).

  See [Updating CMake](#updating-cmake) for details on how to install the latest
  `cmake`. Ubuntu 20.04 comes with a sufficient version of `cmake` out of the box.



  The C++ portion of `ctrl-utils` is header-only, but to add `ctrl-utils` as a
  `cmake` dependency, you can run the following:
  ```sh
  mkdir build
  cmake -B build
  ```



  Use `pip` to install `ctrl-utils` in your virtual environment.
  ```sh
  pip install .
  ```

  You can now import the `ctrlutils` package in Python.
  ```py
  import ctrlutils
  ```



  An in-place `pip` install will run the appropriate CMake command to build
  `ctrl-utils` locally in the `./build` folder. This will give you access to the
  `cmake` configuration files for C++ as well as the `ctrlutils` package in
  Python.
  ```sh
  pip install -e .
  ```





  The simplest way to install the latest version of `cmake` is through `pip`:
  ```sh
  pip install cmake
  ```

  You can also install it through `apt`:
  ```sh
  sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates gnupg wget
  wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /etc/apt/trusted.gpg.d/kitware.gpg >/dev/null
  sudo apt-add-repository -y 'deb https://apt.kitware.com/ubuntu/ bionic main'
  sudo apt-get update && sudo apt-get install -y cmake kitware-archive-keyring
  sudo rm /etc/apt/trusted.gpg.d/kitware.gpg
  ```



  Install `cmake` through Homebrew:
  ```sh
  brew install cmake
  ```

  Or through `pip`:
  ```sh
  pip3 install cmake
  ```

rpm_license:
  MIT License  Copyright (c) 2019 Toki Migimatsu  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: 58dff6b00ea08c9fe2b358e24df5cfd6c6c114fbda971d6d5557dca5872d060a
name: python-ctrutils
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Libreria de utilidades varias
url: https://pypi.org/project/ctrutils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctrutils-4.0.2-1.src.rpm
checksum_type: sha256
description:
  **ctrutils** es una librería de utilidades en Python creada para simplificar y automatizar tareas comunes en ciencia de datos y desarrollo. Este proyecto está en desarrollo y puede estar sujeto a cambios.



  Para saber más sobre el uso de la librería **ctrutils**, visite la documentación en [readthedocs](https://ctrutils.readthedocs.io/es/latest/index.html#).



  ¡Las contribuciones son bienvenidas! Si encuentras algún problema o tienes alguna mejora, no dudes en abrir un issue o enviar un pull request.



  Si tienes alguna pregunta o sugerencia, no dudes en contactarnos a traves de [GitHub](https://github.com/ctrutils/ctrutils/issues) o mediante el correo electrónico [tacoronteriverocristian@gmail.com](mailto:tacoronteriverocristian@gmail.com).



  Este proyecto está bajo la siguiente [licencia](https://github.com/TacoronteRiveroCristian/ctrutils/blob/main/LICENSE).


pkgId: 04ce429ed6a5e4e091859c4d45f9023b933cd44ebe18908023a2d197d841b8cc
name: python-ctwin32
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Access selected win32 APIs through ctypes
url: https://pypi.org/project/ctwin32/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctwin32-3.0.0-1.src.rpm
checksum_type: sha256
description:
  ctwin32 is a pure Python module, that wraps some Windows APIs ([win32](
  https://learn.microsoft.com/en-us/windows/win32/api/)) by using
  [ctypes](https://docs.python.org/3/library/ctypes.html). Since it is my personal
  playground, the selection of supported APIs and the way those are wrapped are
  solely dictated by my needs and preferences.
  ctwin32 is *__definitely__* not a replacement for
  [pywin32](https://pypi.org/project/pywin32/), although it serves that purpose
  for me (in conjunction with [comtypes](https://pypi.org/project/comtypes/)).
  Compared with pywin32 the coverage of ctwin32 is downright tiny.
  While there is already another Python module that does something very similar
  to ctwin32 ([pywin32-ctypes](https://github.com/enthought/pywin32-ctypes)),
  it has a different purpose (namely to serve the internal needs of its
  [creator](https://www.enthought.com/)).
  See the
  [samples directory](https://github.com/RoccoMatano/ctwin32/tree/master/samples)


pkgId: 905682e591ca48ea1bd130c69b8482afa7e3cdeba35bb4a1f12337f009b7aae1
name: python-ctx-python
arch: src
version: 0.0.1a4
epoch: 0
release: 1
summary: A Python API client for US EPA's Computational Toxicology and Exposure APIs.
url: https://github.com/USEPA/ctx-python
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctx-python-0.0.1a4-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for U.S. EPA's Center for Computational Toxicology and Exposure (CTE) APIs.


  `ctx-python` is available to install via `pip`.

  ```
  pip install ctx-python
  ```


  **Before being able to access CCTE's API, a user must acquire an API key.** See [https://api-ccte.epa.gov/docs/](https://api-ccte.epa.gov/docs/) for more information.

  Once an API key is obtained, `ctx-python` offers two options for passing the key for authentication:

  1. Supply the key at the point of instantiatation for each domain. This will look something like:

  ```{python}
  import ctxpy as ctx

  chem = ctx.Chemical(x_api_key='648a3d70')
  ```

  2. `ctx-python` comes with a command-line tool that will utilize the `.env` file that will store the key. If no key is supplied at instantiation, `ctx-python` will automatically attempt to load this file and use a key stored there.
  ```{bash}
  [user@host~]$ ctx_init --x-api-key 648a3d70
  ```
  This will result in the .env file having three new environment variables added to the file: `ctx_api_host`, `ctx_api_accept`, `ctx_x_api_key`.

  ```{python}
  import ctxpy as ctx

  chem = ctx.Chemical()
  ```


  The backbone of `ctx-python` is its base `Connection` class. This class takes the appropriate authentication key and other important information for GET and POST commands and stores them for each call to the API. There are 5 different domains that have a specific `Connection` sub-class:
  - Chemical
  - Exposure
  - Hazard (comming soon)
  - Bioactivity (comming soon)
  - Ecotox (comming soon)


  The `Chemical` class provides capabilities to:
  - search for chemicals by their names, CAS-RNs, DTXSIDs, or other potential identifiers
  - retrieve details about a chemical from a DTXSID (single chemical or batch search) or DTXCID (single chemical only)
  - search for chemicals that match features common in Mass Spectrometry (i.e., a range of molecular mass, chemical formula, or by DTXCID)

  ```{python}
  import ctx


  chem = ctx.Chemical()


  chem.search(by='equals',word='toluene')
  chem.search(by='starts-with',word='atra')
  chem.search(by='contains',word='-00-')
  chem.search(by='batch',word=['50-00-0','BPA'])



  chem.details(by='dtxsid', word='DTXSID7020182')
  chem.details(by='dtxcid', word='DTXCID701805')
  chem.details(by='batch', word=['DTXSID7020182','DTXSID3021805'])


  chem.msready(by='dtxcid',word='DTXCID30182')
  chem.msready(by='formula', word='C17H19NO3')
  chem.msready(by='mass', start=200.9, end=200.93)
  ```


  The `Exposure` class provides capabilities to:
  - search for a chemical's:
      - reported functional use information
      - predicted functional uses
      - presence in consumer/industrial formulations or articles
      - presence in annotated chemical list
  - retrieve controlled vocabularies for:
      - Function Categories (FC)
      - Product Use Categories (PUC)
      - List Presence Keywords (LPKs)

  ```{python}
  import ctx


  expo = ctx.Exposure()


  expo.search(by="fc",word="DTXSID7020182")
  expo.search(by='qsur',word='DTXSID7020182')
  expo.search(by='puc',word='DTXSID7020182')
  expo.search(by='lpk', word='DTXSID7020182')



  expo.vocabulary(by='fc')
  expo.vocabulary(by='puc')
  expo.vocabulary(by='lpk')
  ```


  This software/application was developed by the U.S. Environmental Protection Agency (USEPA). No warranty expressed or implied is made regarding the accuracy or utility of the system, nor shall the act of distribution constitute any such warranty. The USEPA has relinquished control of the information and no longer has responsibility to protect the integrity, confidentiality or availability of the information. Any reference to specific commercial products, processes, or services by service mark, trademark, manufacturer, or otherwise, does not constitute or imply their endorsement, recommendation or favoring by the USEPA. The USEPA seal and logo shall not be used in any manner to imply endorsement of any commercial product or activity by the USEPA or the United States Government.


pkgId: c346292db0a402ad0703663e90df1d486e61dc29294f8abecf61da73a8748662
name: python-ctxl
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A CLI tool to dump projects into an LLM ideal format.
url: https://github.com/caesarnine/ctxl
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctxl-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ctxl.svg)](https://badge.fury.io/py/ctxl)
  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

  ctxl is a CLI tool designed to transform project directories into a structured XML format suitable for language models and AI analysis. It intelligently extracts file contents and directory structures while respecting gitignore rules and custom filters. A key feature of ctxl is its ability to automatically detect project types (such as Python, JavaScript, or web projects) based on the files present in the directory. This auto-detection enables ctxl to make smart decisions about which files to include or exclude, ensuring that the output is relevant and concise. Users can also override this auto-detection with custom presets if needed.

  The tool creates a comprehensive project snapshot that can be easily parsed by LLMs, complete with a customizable task specification. This task specification acts as a prompt, priming the LLM to provide more targeted and relevant assistance with your project.

  ctxl was developed through a bootstrapping process, where each version was used to generate context for an LLM in developing the next version.


  - [Why ctxl?](#why-ctxl)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
    - [Workflow](#workflow)
  - [How It Works](#how-it-works)
  - [Usage](#usage)
    - [Basic Usage](#basic-usage)
    - [Command-line Options](#command-line-options)
    - [Presets](#presets)
  - [Features](#features)
  - [Output Example](#output-example)
  - [Integration with LLMs](#integration-with-llms)
  - [Project Structure](#project-structure)
  - [Troubleshooting](#troubleshooting)
  - [Contributing](#contributing)
  - [License](#license)



  ctxl streamlines the process of providing project context to LLMs. Instead of manually copying and pasting file contents or explaining your project structure, ctxl automatically generates a comprehensive, structured representation of your project. This allows LLMs to have a more complete understanding of your codebase, leading to more accurate and context-aware assistance.



  To install ctxl, you can use pip:

  ```bash
  pip install ctxl
  ```



  After installation, you can quickly generate an XML representation of your project:

  ```bash
  ctxl /path/to/your/project > project_context.xml
  ```

  This command will create an XML file which you can then provide to an LLM for analysis or assistance. The XML output includes file contents, directory structure, and a default task description that guides the LLM in analyzing your project.



  This is how I've been using it - essentially as a iterative process.

  1. Paste this directly into your LLM's chat interface (or via API/CLI) and let it respond first. I've found the latest Claude models (Sonnet 3.5 as of writing this) to work best.
  2. The LLM will respond with a thorough breakdown and summary of the project first, which helps to prime the LLM with a better contextual understanding of the project, frameworks/libraries used, and overall user/data flow.
  3. Chat with it as normal after. You can ask for things like:
      >I'd like to update the frontend to show live progress when the backend is processing documents.

  4. The LLM will use the context of your entire project to suggest refactors/updates to all the relevant files involved to fulfill that ask.
  5. Update those files/sections, see if it works/if you like it, if not give feedback/error messages back to the model and keep iterating on.

  Future improvements to ctxl will likely automate #4 and #5 of this process.



  ctxl operates in several steps:
  1. It scans the specified directory to detect the project type(s).
  2. Based on the detected type(s) or user-specified presets, it determines which files to include or exclude.
  3. It reads the contents of included files and constructs a directory structure.
  4. If enabled, it analyzes Python dependencies within the project and includes a dependency tree.
  5. All this information is then formatted into an XML structure, along with the specified task.
  6. The resulting XML is output to stdout or a specified file.





  To use ctxl, simply run the following command in your terminal:

  ```bash
  ctxl /path/to/your/project
  ```

  By default, this will output the XML representation of your project to stdout. This allows for piping the output into other CLI tools, for example with [LLM](https://github.com/simonw/llm):

  ```bash
  ctxl /path/to/your/project | llm
  ```

  To output to a file:

  ```bash
  ctxl /path/to/your/project > context.xml
  ```

  or

  ```bash
  ctxl /path/to/your/project -o context.xml
  ```



  ctxl offers several command-line options to customize its behavior:

  - `-o, --output`: Specify the output file path (default: stdout)
  - `--presets`: Choose preset project types to combine (default: auto-detect)
  - `--filter`: Filter patterns to include or exclude (!) files. Example: `'*.py !__pycache__'`
  - `--include-dotfiles`: Include dotfiles and folders in the output
  - `--gitignore`: Specify a custom .gitignore file path
  - `--task`: Include a custom task description in the output
  - `--no-auto-detect`: Disable auto-detection of project types
  - `--view-presets`: Display all available presets (both built-in and custom)
  - `--save-presets`: Save the built-in presets to a YAML file for easy customization
  - `--analyze-deps`: Analyze project dependencies (default: True)
  - `-v, --verbose`: Enable verbose logging for more detailed output

  Example:

  Use existing presets with additional filters to include `.log` and `.txt` and exclude a `temp` directory.

  ```bash
  ctxl /path/to/your/project --presets python javascript --output project_context.xml --task "Analyze this project for potential security vulnerabilities" --filter *.log *.txt !temp
  ```

  Don't use any presets and fully control what to include/exclude.

  ```bash
  ctxl /path/to/your/project --no-auto-detect --output project_context.xml --task "Analyze this project for potential security vulnerabilities" --filter *.py *.js *.md !node_modules
  ```

  To view all available presets:

  ```bash
  ctxl --view-presets
  ```

  To save the built-in presets to a YAML file. You can then modify these/add your own, if this file exists in the directory you're running ctxl on then they'll automatically be loaded in and used instead of the defaults.

  ```bash
  ctxl --save-presets
  ```

  To enable verbose logging:

  ```bash
  ctxl /path/to/your/project -v
  ```



  ctxl includes presets for common project types:

  - python: Includes .py, .pyi, .pyx, .ipynb files, ignores common Python-specific directories and files
  - javascript: Includes .js, .jsx, .mjs, .cjs files, ignores node_modules and other JS-specific files
  - typescript: Includes .ts, .tsx files, similar ignores to JavaScript
  - web: Includes .html, .css, .scss, .sass, .less, .vue files
  - java: Includes .java files, ignores common Java build directories
  - csharp: Includes .cs, .csx, .csproj files, ignores common C# build artifacts
  - go: Includes .go files, ignores vendor directory
  - ruby: Includes .rb, .rake, .gemspec files, ignores bundle-related directories
  - php: Includes .php files, ignores vendor directory
  - rust: Includes .rs files, ignores target directory and Cargo.lock
  - swift: Includes .swift files, ignores .build and Packages directories
  - kotlin: Includes .kt, .kts files, ignores common Kotlin/Java build directories
  - scala: Includes .scala, .sc files, ignores common Scala build directories
  - docker: Includes Dockerfile, .dockerignore, and docker-compose files
  - misc: Includes common configuration and documentation file types

  The tool automatically detects project types, but you can also specify them manually using the `--presets` option.



  - Auto-detects project types and respects .gitignore rules to determine what files to include/exclude
  - Fully customizable file inclusion/exclusion via `--filter` if you need more control
  - Generates AI-ready XML output with custom task descriptions
  - Simple CLI for easy integration into development workflows
  - Efficiently handles large, polyglot projects
  - Supports a wide range of programming languages and frameworks
  - Customizable presets with ability to view and save presets
  - Verbose logging option for detailed process information
  - Dependency analysis for Python projects (enabled by default)



  Here's an example of what the XML output might look like when run on the ctxl project itself.

  To generate this output, you would run:

  ```bash
  ctxl /path/to/ctxl/repository --output ctxl_context.xml
  ```

  The resulting `ctxl_context.xml` would look something like this:

  ```xml
  <root>
    <project_context>
      <file path="src/ctxl/ctxl.py">
        <content>
          ...truncated for examples sake...
        </content>
      </file>
      <file path="src/ctxl/__init__.py">
        <content>
          ...truncated for examples sake...
        </content>
      </file>
      <file path="pyproject.toml">
        <content>
          ...truncated for examples sake...
        </content>
      </file>
      <directory_structure>
        <directory path=".">
          <file path="README.md" />
          <file path="pyproject.toml" />
          <directory path="src">
            <directory path="src/ctxl">
              <file path="src/ctxl/ctxl.py" />
              <file path="src/ctxl/__init__.py" />
            </directory>
          </directory>
        </directory>
      </directory_structure>
      <dependencies>
        <file path="src.ctxl.ctxl">
          <upstream>
            <external>
              <dependency>argparse</dependency>
              <dependency>logging</dependency>
              ...
            </external>
            <internal>
              <dependency>src.ctxl.dependency_analyzer</dependency>
              <dependency>src.ctxl.preset_manager</dependency>
            </internal>
          </upstream>
          <downstream />
        </file>
        ...
      </dependencies>
    </project_context>
    <task>Describe this project in detail. Pay special attention to the structure of the code, the design of the project, any frameworks/UI frameworks used, and the overall structure/workflow. If artifacts are available, then use workflow and sequence diagrams to help describe the project.</task>
  </root>
  ```

  The XML output provides a comprehensive view of the ctxl project, including file contents, structure, dependencies, and a task description. This format allows LLMs to easily parse and understand the project context, enabling them to provide more accurate and relevant assistance.



  The ctxl project has the following structure:

  ```
  ctxl/
  ├── src/
  │   └── ctxl/
  │       ├── __init__.py
  │       ├── ctxl.py
  │       ├── preset_manager.py
  │       └── dependency_analyzer.py
  ├── README.md
  └── pyproject.toml
  ```

  The main functionality is implemented in `src/ctxl/ctxl.py`, with preset management handled in `src/ctxl/preset_manager.py` and dependency analysis in `src/ctxl/dependency_analyzer.py`.



  - **Issue**: ctxl is not detecting my project type correctly.
    **Solution**: Use the `--presets` option to manually specify the project type(s).

  - **Issue**: ctxl is including/excluding files I don't want.
    **Solution**: Use the `--filter` option, if you want full control use `--filter` with `--no-auto-detect`.

  - **Issue**: The XML output is too large for my LLM to process.
    **Solution**: Try using more specific presets or custom ignore patterns to reduce the amount of included content.

  - **Issue**: I need more information about what ctxl is doing.
    **Solution**: Use the `-v` or `--verbose` flag to enable verbose logging for more detailed output.

  - **Issue**: The dependency analysis is not working or is causing errors.
    **Solution**: You can disable dependency analysis with `--analyze-deps false` if it's causing issues.



  Contributions to ctxl are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the Apache License, Version 2.0. See the LICENSE file for details.


pkgId: 1770c40fcc853ef50af4a248bc0fc2a97b2272e7ab7725017ad4f11346923922
name: python-ctype
arch: src
version: 7.4.2
epoch: 0
release: 1
summary: Interact with cython, python, ctypes, and use other c/c++ tools
url: https://github.com/notepads/ctype
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctype-7.4.2-1.src.rpm
checksum_type: sha256
description:
  <a href="[https://ibb.co/r4RCDff](https://i.ibb.co/wMF95rr/ctype.png)"><img src="https://i.ibb.co/wMF95rr/ctype.png" alt="flowa" border="0" width="145"></a>


  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/notepads-py/ctype/blob/main/LICENSE)
  [![Python Versions](https://img.shields.io/badge/python-3.7%20|%203.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12%20-blue)](https://www.python.org/downloads/)

  ```
  ctype: (V7.4.2)

  Interact with cython, python, ctypes, and use other c/c++ tools
  ```


  ```shell

  python3 pip install -U ctype


  py -3 -m pip install -U ctype
  ```

  ```python
  import ctype
  ```
  ```python

  ctype.CType         # Decorator Class
  ctype.Structure
  ```
  ```python
  ctype.uint
  ctype.uint4
  ctype.uint8
  ctype.uint16
  ctype.uint32
  ctype.uint64
  ```
  ```python
  ctype.ints
  ctype.int4
  ctype.int8
  ctype.int16
  ctype.int32
  ctype.int64
  ```
  ```python
  ctype.floats
  ctype.float4
  ctype.float8
  ctype.float16
  ctype.float32
  ctype.float64
  ```
  ```python
  ctype.double
  ctype.double4
  ctype.double8
  ctype.double16
  ctype.double32
  ctype.double64
  ```
  ```python
  ctype.long
  ctype.longlong
  ctype.short
  ```
  ```python
  ctype.ulong
  ctype.ulonglong
  ctype.ushort
  ```
  ```python
  ctype.char
  ctype.wchar
  ctype.chararray
  ctype.wchararray
  ```
  ```python
  ctype.struct
  ctype.union
  ctype.enum
  ```
  ```python
  ctype.typedef
  ctype.volatile
  ```
  ```python
  ctype.boolean
  ```
  ```python
  ctype.void
  ```
  ```python
  ctype.ptr
  ```
  ```python
  ctype.cout, ctype.stdout, ctype.printf
  ctype.cin, ctype.stdin
  ctype.cerr, ctype.stderr
  ctype.clog, ctype.log
  ctype.cexit, ctype.exit
  ctype.cabort, ctype.abort
  ctype.endl
  ```
  ```python

  ctype.ctype_err <cerr_type> <cobject> <cmessage>

  ctype.CTypeException
  ctype.CTypeRuntime
  ctype.CTypeIndex
  ctype.CTypeName
  ctype.CTypeImport
  ctype.CTypeAttr
  ctype.CTypeKey
  ctype.CTypeValue
  ctype.CTypeIndent
  ctype.CTypeError
  ctype.CTypeKeyboard
  ctype.CTypeUnfinished
  ```

  ```python


  from ctype import cdll, c_int, c_char_p, c_void_p, c_double, c_bool, ...
  ```
  ```python

  ctype.types


  ctype.ctype
  ctype.CType


  ctype.Structure
  ctype.Struct
  ctype.structure
  ```
  ```python
  ctype.require('a_module', 'numpy', 'some_other_module')
  ```


  - [Github](https://github.com/notepads-ai)
  - [Project](https://pypi.org/project/ctype/)


pkgId: c2e748082b226a110f2ca00217920d22bdc685c43f4e38c39926db1fb81932de
name: python-ctypes-window-info
arch: src
version: 0.15
epoch: 0
release: 1
summary: Get window/process information with ctypes, no dependencies
url: https://github.com/hansalemaos/ctypes_window_info
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctypes-window-info-0.15-1.src.rpm
checksum_type: sha256
description:
  ```python

  This function utilizes the Windows API to retrieve information about windows.

  Args:
      hwnd (int or None): The handle of the window for which to retrieve the text, defaults to None (all windows).

  Returns:
      namedtuple: A named tuples with - pid title windowtext hwnd length tid status coords_client dim_client coords_win dim_win class_name path

  Note:
      This function uses the `GetWindowTextW` function from the `user32` library to retrieve the window text.
      It is intended for use on Windows operating systems and relies on the ctypes library to interface with the Windows API.

  Examples:
      from ctypes_window_info import get_window_infos

      get_window_infos()

      [[WindowInfo(pid=88, title='Base_PowerMessageWindow', windowtext='', hwnd=197614, length=1, tid=9668, status='invisible', coords_client=(0, 0, 0, 0), dim_client=(0, 0), coords_win=(0, 0, 0, 0), dim_win=(0, 0), class_name='Base_PowerMessageWindow', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       WindowInfo(pid=88, title='Chrome_StatusTrayWindow', windowtext='', hwnd=197592, length=1, tid=9668, status='invisible', coords_client=(0, 0, 0, 0), dim_client=(0, 0), coords_win=(0, 0, 0, 0), dim_win=(0, 0), class_name='Chrome_StatusTrayWindow', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       WindowInfo(pid=88, title='Chrome_SystemMessageWindow', windowtext='', hwnd=197600, length=1, tid=9668, status='invisible', coords_client=(0, 130, 0, 10), dim_client=(130, 10), coords_win=(0, 136, 0, 39), dim_win=(136, 39), class_name='Chrome_SystemMessageWindow', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       WindowInfo(pid=88, title='Chrome_WidgetWin_0', windowtext='', hwnd=197580, length=1, tid=9668, status='invisible', coords_client=(0, 0, 0, 0), dim_client=(0, 0), coords_win=(0, 0, 0, 0), dim_win=(0, 0), class_name='Chrome_WidgetWin_0', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       WindowInfo(pid=88, title='Chrome_WidgetWin_0', windowtext='', hwnd=197606, length=1, tid=9668, status='invisible', coords_client=(0, 1424, 0, 728), dim_client=(1424, 728), coords_win=(182, 1622, 182, 949), dim_win=(1440, 767), class_name='Chrome_WidgetWin_0', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       WindowInfo(pid=88, title='Chrome_WidgetWin_1', windowtext='', hwnd=2492886, length=1, tid=9668, status='invisible', coords_client=(0, 64, 0, 64), dim_client=(64, 64), coords_win=(-1, 63, 1028, 1092), dim_win=(64, 64), class_name='Chrome_WidgetWin_1', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'),
       ....

       get_window_infos(197614)
       [WindowInfo(pid=88, title='Base_PowerMessageWindow', windowtext='', hwnd=197614, length=1, tid=9668, status='invisible', coords_client=(0, 0, 0, 0), dim_client=(0, 0), coords_win=(0, 0, 0, 0), dim_win=(0, 0), class_name='Base_PowerMessageWindow', path='C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe')]

  ```


pkgId: 95c55941031e61a928cc6ba862f290ea0adab0e00a9a8d5412c88e4f29cd2921
name: python-ctypes-windows-sdk
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: Ctypes port of Windows SDK
url: https://github.com/Dobatymo/ctypes-windows-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctypes-windows-sdk-0.0.15-1.src.rpm
checksum_type: sha256
description:
  A totally incomplete and random port of the C Windows SDK for Python ctypes. No dependencies besides the Python standard library.



  Requires Python 3.7+.

  ```
  pip install ctypes-windows-sdk
  ```



  ```python

  from cwinsdk.windows import GetTickCount64
  tickcount = GetTickCount64()
  ```


  - Dobatymo/public-scripts


pkgId: 9a2405786a37bc7bc35cba0182ca8cad1ded29b003b2b3e0b0576afba28c82b6
name: python-ctypesgen
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Python wrapper generator for ctypes
url: https://github.com/ctypesgen/ctypesgen
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctypesgen-1.1.1-1.src.rpm
checksum_type: sha256
description:
                    (c) Ctypesgen developers 2007-2022
                   https://github.com/ctypesgen/ctypesgen
  _ctypesgen_ is a pure-python ctypes wrapper generator. It parses C header files
  and creates a wrapper for libraries based on what it finds.
  Preprocessor macros are handled in a manner consistent with typical C code.
  Preprocessor macro functions are translated into Python functions that are then
  made available to the user of the newly-generated Python wrapper library.
  It can also output JSON, which can be used with Mork, which generates bindings
  for Lua, using the alien module (which binds libffi to Lua).

  See https://github.com/ctypesgen/ctypesgen/wiki for full documentation.
  Run `ctypesgen --help` for full range of available options.

  _ctypesgen_ can be installed by `pip install ctypesgen`. It requires Python 3.7
  to run.

  This project automatically generates ctypes wrappers for header files written
  in C.
  For example, if you'd like to generate Neon bindings, you can do so using this
  recipe (using a standard pip install):
  ```sh
  ctypesgen -lneon /usr/local/include/neon/ne_*.h -o neon.py
  ```
  Some libraries, such as APR, need special flags to compile. You can pass these
  flags in on the command line.
  For example:
  ```sh
  FLAGS = `apr-1-config --cppflags --includes`
  ctypesgen $FLAGS -llibapr-1.so $HOME/include/apr-1/apr*.h -o apr.py
  ```
  Sometimes, libraries will depend on each other. You can specify these
  dependencies using -mmodule, where module is the name of the dependency module.
  Here's an example for apr_util:
  ```sh
  ctypesgen $FLAGS -llibaprutil-1.so $HOME/include/apr-1/ap[ru]*.h \
  	-mapr -o apr_util.py
  ```
  If you want JSON output (e.g. for generating Lua bindings), use
  ```
  --output-language=json
  ```
  When outputting JSON, you will probably also want to use
  ```
  --all-headers --builtin-symbols --no-stddef-types --no-gnu-types
  --no-python-types
  ```

  _libffi_ is a portable Foreign Function Interface library:
  http://sources.redhat.com/libffi/
  _Mork_, the friendly alien, can be found at:
  https://github.com/rrthomas/mork

  _ctypesgen_ is distributed under the New (2-clause) BSD License:
  http://www.opensource.org/licenses/bsd-license.php
  Copyright (c) 2007-2022, Ctypesgen Developers
  All rights reserved.
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
  1. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.


  - Fixed inconsistency in version output in released packages

  This release has a number of bug fixes in addition to a few new features.
  Following a complete transition to Python 3, with dropped Python 2 support,
  major work was made towards code modernization and quality.
  - The code is now Black formatted and Flake8 tested
  - Greatly improved unittest framework
  - Embedded PLY version updated to 3.11
  - New option: `--no-embed-preamble` create separate files for preamble and
    loader instead of embedding in each output file
  - New option: `--allow-gnu-c` do not undefine `__GNUC__`
  - Fixed library loader search path on macOS
  - Fixed rare bug, processing (legacy) header files with MacRoman encoding
    on macOS
  - Added full support for floating and integer constants
  - Added support for sized integer types on Windows
  - Added support to handle `restrict` and `_Noreturn` keywords
  - Added name formats to posix library loader
  - Fixed mapping of 'short int' to c_short
  - Git tags are now using `x.y.z` format

  Many issues fixed. Parse gcc attributes more
  Implements automatic calling convention selection based on gcc attributes for
  stdcall/cdecl.
  - Simplify and unify library loader for various platforms. Improve library path
    searches on Linux (parsed ld.so.conf includes now).
  - First implementaion of #pragma pack
  - First implemenation of #undef
  - Adds several command line options:
    `-D` `--define`
    `-U` `--undefine`
    `--no-undefs`
    `-P` `--strip-prefix`
    `--debug-level`

  Fix handling of function prototypes
  Other minor improvments included.

  Py2/Py3 support
  Various development branches merged back
  In addition to the various developments from the different branches, this
  tag also represents a code state that:
  - ties in with Travis CI to watch code developments
  - improves testsuite, including moving all JSON tests to testsuite
  - includes a decent Debian package build configuration
  - automatically creates a man page to be included in the Debian package


pkgId: fd716367a052946467ab5baa8caaf0c9d4184bf672e121478fe08fbfcb68575b
name: python-ctypeslib2
arch: src
version: 2.3.4
epoch: 0
release: 1
summary: ctypeslib2 - FFI toolkit, relies on clang
url: https://github.com/trolldbois/ctypeslib
rpm_license: License :: OSI Approved :: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ctypeslib2-2.3.4-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/trolldbois/ctypeslib/workflows/ctypeslib-linux/badge.svg)

  [![Coverage Status](https://coveralls.io/repos/github/trolldbois/ctypeslib/badge.svg?branch=master)](https://coveralls.io/github/trolldbois/ctypeslib?branch=master)

  [![Latest release](https://img.shields.io/github/tag/trolldbois/ctypeslib.svg)]()
  [![Supported versions](https://img.shields.io/pypi/pyversions/ctypeslib2.svg)]()

  ![PyPI](https://img.shields.io/pypi/v/ctypeslib)
  ![Python](https://img.shields.io/pypi/pyversions/ctypeslib)

  [Quick usage guide](docs/ctypeslib_2.0_Introduction.ipynb) in the docs/ folder.



   - 2023-04:
     - Please read the installation instructions
   - 2021-02:
     - Thanks for the pull requests
     - Note: libclang-xx-dev must be installed for stddef and other reasons.
     - bump to libclang-11
   - 2018-01-03: master branch works with libclang-5.0 HEAD, python clang from pypi, python3
   - 2017-05-01: master branch works with libclang-4.0 HEAD




  First, you should install LLVM clang.
  See the LLVM Clang instructions at http://apt.llvm.org/ or use your distribution's packages.

  Either use an installer relevant for your OS (APT, downloads, etc..) to install libclang
  ```
  $ sudo apt install libclang1-11
  ```

  or you can use the LLVM install script that installs the whole llvm toolkit
  ```
   wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh
   
   ./llvm.sh 16
   
   ./llvm.sh 11
  ```
  or you can use anaconda, or any local installation of your favorite choice


  Then, install ctypeslib2 and the clang python package with the **same version as your llvm clang library**.

  Stable Distribution is available through PyPi at https://pypi.python.org/pypi/ctypeslib2/
  if you are not using the latest LLVM clang version, you will need to specify the correct clang python package version

    - If you have installed the latest llvm version: `pip install ctypeslib2` should work fine
    - If you are using llvm clang 16: `pip install ctypeslib2 clang==16`
    - If you are using llvm clang 14: `pip install ctypeslib2 clang==14`
    - If you are using llvm clang 11: `pip install ctypeslib2 clang==11`
    - etc...



  On Ubuntu, libclang libraries are installed with version in the filename.
  This library tries to load a few different versions to help you out. (`__init__.py`)
  But if you encounter a version compatibility issue, you might have to fix the problem
  using one of the following solutions:

  1. set the CLANG_LIBRARY_PATH environmental variable to the clang library file or path
  ```
  $ export CLANG_LIBRARY_PATH=/lib/x86_64-linux-gnu/libclang-11.so.1
  $ clang2py --version
  versions - clang2py:2.3.3 clang:11.1.0 python-clang:11.0
  ```

  2. OR Install the development package libclang-<version\>-dev to get a file called libclang.so

  `$ sudo apt get install libclang-11-dev`
  2. OR create a link to libclang-<version\>.so.1 named libclang.so
  3. OR hardcode a call to clang.cindex.Config.load_library_file('libclang-<version\>.so.1') in your code before importing ctypeslib






      import ctypeslib
      py_module = ctypeslib.translate('''int i = 12;''')
      print(py_module.i)  # Prints 12

      py_module2 = ctypeslib.translate('''struct coordinates { int i ; int y; };''')
      print(py_module2.struct_coordinates)  # <class 'struct_coordinates'>
      print(py_module2.struct_coordinates(1,2))  # <struct_coordinates object at 0xabcde12345>

      
      py_module3 = ctypeslib.translate_files(['mytest.c'], outfile=open('mytest.py', 'w'))
      print(open('mytest.py').read())

      
      py_module4 = ctypeslib.translate_files(['mytest.c'])
      print(open('mytest.py').read())

      
      from ctypeslib.codegen import config
      cfg = config.CodegenConfig()
      cfg.clang_opts.extend(['-target', 'arm-gnu-linux'])
      py_module5 = ctypeslib.translate_files(['mytest.c'], cfg=cfg)
      print(open('mytest.py').read())


  Look at `test/test_api.py` for more advanced Library usage




  Source file:

      $ cat t.c
      struct my_bitfield {
      long a:3;
      long b:4;
      unsigned long long c:3;
      unsigned long long d:3;
      long f:2;
      };

  Run c-to-python script:

      clang2py t.c

  Output:

      
      
      
      
      
      
      
      import ctypes

      class struct_my_bitfield(ctypes.Structure):
          _pack_ = True # source:False
          _fields_ = [
          ('a', ctypes.c_int64, 3),
          ('b', ctypes.c_int64, 4),
          ('c', ctypes.c_int64, 3),
          ('d', ctypes.c_int64, 3),
          ('f', ctypes.c_int64, 2),
          ('PADDING_0', ctypes.c_int64, 49)]

      __all__ = \
          ['struct_my_bitfield']



  Source file:

      $ cat test-stdbool.c
      

      typedef struct s_foo {
      bool bar1;
      bool bar2;
      bool bar3;
      } foo;


  Run c-to-python script (with any relevant include folder):

      clang2py --clang-args="-I/usr/include/clang/4.0/include" test-stdbool.c

  Output:

      
      
      
      
      
      
      
      import ctypes

      class struct_s_foo(ctypes.Structure):
          _pack_ = True # source:False
          _fields_ = [
          ('bar1', ctypes.c_bool),
          ('bar2', ctypes.c_bool),
          ('bar3', ctypes.c_bool),]

      foo = struct_s_foo
      __all__ = ['struct_s_foo', 'foo']




      clang2py test/data/test-record.c

  This outputs:

      

      class struct_Node2(Structure):
          _pack_ = True # source:False
          _fields_ = [
          ('m1', ctypes.c_ubyte),
          ('PADDING_0', ctypes.c_ubyte * 7),
          ('m2', POINTER_T(struct_Node)),]

      

  The PADDING_0 field is added to force the ctypes memory Structure to align fields offset with the definition given
  by the clang compiler.

  The [_pack_](https://docs.python.org/3/library/ctypes.html#ctypes.Structure._pack_) attribute forces the alignment
  on 0 bytes, to ensure all fields are as defined by this library, and not per the compiler used by the host python binary

  The objective of this, is to be able to produce cross-architecture python code, that can read memory structures from a
  different architecture (like reading a memory dump from a different architecture)

  See `clang-11 -print-targets` for options




      usage: clang2py [-h] [-c] [-d] [--debug] [-e] [-k TYPEKIND] [-i] [-l DLL] [-m module] [--nm NM] [-o OUTPUT] [-p DLL] [-q] [-r EXPRESSION] [-s SYMBOL] [-t TARGET] [-v] [-V] [-w W] [-x] [--show-ids SHOWIDS] [--max-depth N]
                      [--validate VALIDATE] [--clang-args CLANG_ARGS]
                      files [files ...]

      Version 2.3.3. Generate python code from C headers

      positional arguments:
        files                 source filenames. stdin is not supported

      options:
        -h, --help            show this help message and exit
        -c, --comments        include source doxygen-style comments
        -d, --doc             include docstrings containing C prototype and source file location
        --debug               setLevel to DEBUG
        -e, --show-definition-location
                              include source file location in comments
        -k TYPEKIND, --kind TYPEKIND
                              kind of type descriptions to include: a = Alias, c = Class, d = Variable, e = Enumeration, f = Function, m = Macro, #define s = Structure, t = Typedef, u = Union default = 'cdefstu'
        -i, --includes        include declaration defined outside of the sourcefiles
        -l DLL, --include-library DLL
                              library to search for exported functions. Add multiple times if required
        -m module, --module module
                              Python module(s) containing symbols which will be imported instead of generated
        --nm NM               nm program to use to extract symbols from libraries
        -o OUTPUT, --output OUTPUT
                              output filename (if not specified, standard output will be used)
        -p DLL, --preload DLL
                              dll to be loaded before all others (to resolve symbols)
        -q, --quiet           Shut down warnings and below
        -r EXPRESSION, --regex EXPRESSION
                              regular expression for symbols to include (if neither symbols nor expressions are specified,everything will be included)
        -s SYMBOL, --symbol SYMBOL
                              symbol to include (if neither symbols nor expressions are specified,everything will be included)
        -t TARGET, --target TARGET
                              target architecture (default: x86_64-Linux)
        -v, --verbose         verbose output
        -V, --version         show program's version number and exit
        -w W                  add all standard windows dlls to the searched dlls list
        -x, --exclude-includes
                              Parse object in sources files only. Ignore includes
        --show-ids SHOWIDS    Don't compute cursor IDs (very slow)
        --max-depth N         Limit cursor expansion to depth N
        --validate VALIDATE   validate the python code is correct
        --clang-args CLANG_ARGS
                              clang options, in quotes: --clang-args="-std=c99 -Wall"

      Cross-architecture: You can pass target modifiers to clang. For example, try --clang-args="-target x86_64" or "-target i386-linux" to change the target CPU arch.




  - clang2py is a script that calls ctypeslib/ctypeslib/clang2py.py
  - clang2py.py is mostly the old xml2py.py module forked to use libclang.
  - clang2py.py calls ctypeslib/ctypeslib/codegen/codegenerator.py
  - codegenerator.py calls ctypeslib/ctypeslib/codegen/clangparser.py
  - clangparser.py uses libclang's python binding to access the clang internal representation of the C source code.
      - It then translate each child of the AST tree to python objects as listed in typedesc.
  - codegenerator.py then uses these python object to generate ctypes-based python source code.

  Because clang is capable to handle different target architecture, this fork
   {is/should be} able to produce cross-platform memory representation if needed.




  This fork of ctypeslib is mainly about using the libclang1>=3.7 python bindings
  to generate python code from C source code, instead of gccxml.

  the original ctypeslib contains these packages:
   - ``ctypeslib.codegen``       - a code generator
   - ``ctypeslib.contrib``       - various contributed modules
   - ``ctypeslib.util``          - assorted small helper functions
   - ``ctypeslib.test``          - unittests

  This fork of ctypeslib is heavily patched for clang.
  - https://github.com/trolldbois/ctypeslib is based on rev77594 of the original ctypeslib.
  - git-svn-id: http://svn.python.org/projects/ctypes/trunk/ctypeslib@775946015fed2-1504-0410-9fe1-9d1591cc4771

  The original ctypeslib is written by
  - author="Thomas Heller",
  - author_email="theller@ctypes.org",


pkgId: 1dd941acfaab53e30ed9109f545952fc7db195af4bf415e7a4e5d4a40871c190
name: python-cu-cat
arch: src
version: 0.9.11
epoch: 0
release: 1
summary: An end-to-end gpu Python library that encodes categorical variables into machine-learnable numerics
url: https://github.com/graphistry/cu-cat
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cu-cat-0.9.11-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/graphistry/cu-cat/blob/e2bae616f84aab8e6d5e173fc5363370d7680dc6/examples/cu_cat.png?raw=true" alt="cu_cat" width="200"/>

  ****cu-cat**** is an end-to-end gpu Python library that encodes
  categorical variables into machine-learnable numerics. It is a cuda
  accelerated port of what was dirty_cat, now rebranded as
  [skrub](https://github.com/skrub-data/skrub), and allows more ambitious interactive analysis & real-time pipelines!

  [Loom video walkthru](https://www.loom.com/share/d7fd4980b31949b7b840b230937a636f?sid=6d56b82e-9f50-4059-af9f-bfdc32cd3509)



  The latest PyGraphistry[AI] release GPU accelerates to its automatic feature encoding pipeline, and to do so, we are delighted to introduce the newest member to the open source GPU dataframe ecosystem: cu_cat!
  The Graphistry team has been growing the library out of need. The straw that broke the camel’s back was in December 2022 when we were hacking on our winning entry to the US Cyber Command AI competition for automatically correlating & triaging  gigabytes of alerts, and we realized that what was slowing down our team's iteration cycles was CPU-based feature engineering, basically pouring sand into our otherwise humming end-to-end GPU AI pipeline. Two months later, cu_cat was born. Fast forward to now, and we are getting ready to make it default-on for all our work.

  Hinted by its name, cu_cat is our GPU-accelerated open source fork of the popular CPU Python  library dirty_cat.   Like dirty_cat, cu_cat makes it easy to convert messy dataframes filled with numbers, strings, and timestamps into numeric feature columns optimized for AI models. It adds interoperability for GPU dataframes and replaces key kernels and algorithms with faster and more scalable GPU variants. Even on low-end GPUs, we are now able to tackle much larger datasets in the same amount of time – or for the first time! – with end-to-end pipelines. We typically save time with **3-5X speedups and will even see 10X+**, to the point that the more data you encode, the more time you save!



  Since **cu_cat** is limited to CUDF/CUML dataframes, it is not a drop-in replacement for dirty_cat.  While it can also fallback to CPU, it is also not a drop-in replacement for the CPU-based dirty_cat, and we are not planning to make it one.  We developed this library to accelerate our own **graphistry** end-to-end pipelines, and as such it is only `TableVectorizer` and `GapEncoder` which have been optimized to take advantage of a GPU speed boost.

  Similarly, **cu_cat** requires pandas or cudf input numpy array can be featurized but cannot be UMAP-ed since they lack index, and are thus not supported.



  We have routinely experienced boosts of 2x on smaller datasets to 10x and more as one scales data into millions of features (features roughly equates to unique elements in rows x columns). One can observe this in the video above, demonstrated in the following plots:

  There is an inflection point when overhead of transing data to GPU is offset by speed boost, as we can see here. The axis represent unique features being inferred.

  ![small](https://github.com/graphistry/cu-cat/blob/e2bae616f84aab8e6d5e173fc5363370d7680dc6/examples/cucat_V_dirty.png?raw=true)

  As we can see, with scale the divergence in speed is obvious.

  ![cu_cat scaling](https://github.com/graphistry/cu-cat/blob/e2bae616f84aab8e6d5e173fc5363370d7680dc6/examples/big_cucat_V_dirty.png?raw=true)

  However, this graph does not mean to imply the trend goes on forever, as currently **cu-cat** is single GPU and cannot batch (as the transfer cost is too much for our current needs), and thus each dataset, and indeed GPU + GPU memory, is unique, and thus these plots are meant merely for demonstrative purposes.
  GPU = colab T4 + 15gb mem and colab CPU + 12gb memory




      ! pip install cu-cat dirty-cat
      from time import time
      from cu_cat._table_vectorizer import TableVectorizer as cu_TableVectorizer
      from dirty_cat._table_vectorizer import TableVectorizer as dirty_TableVectorizer
      from sklearn.datasets import fetch_20newsgroups
      n_samples = 2000  # speed boost improves as n_samples increases, to the limit of gpu mem

      news, _ = fetch_20newsgroups(
          shuffle=True,
          random_state=1,
          remove=("headers", "footers", "quotes"),
          return_X_y=True,
      )

      news = news[:n_samples]
      news=pd.DataFrame(news)
      table_vec = cu_TableVectorizer()
      t = time()
      aa = table_vec.fit_transform((news))
      ct = time() - t
      
      t = time()
      bb = dirty_TableVectorizer().fit_transform(news)
      dt = time() - t
      print(f"cu_cat: {ct:.2f}s, dirty_cat: {dt:.2f}s, speedup: {dt/ct:.2f}x")
      >>> cu_cat: 58.76s, dirty_cat: 84.54s, speedup: 1.44x


      
      !pip install git+https://github.com/graphistry/pygraphistry.git@dev/depman_gpufeat

      import cudf
      import graphistry
      df = cudf.read_csv(...)
      g = graphistry.nodes(df).featurize(feature_engine='cu_cat')
      print(g._node_features.describe()) # friendly dataframe interfaces
      g.umap().plot() # ML/AI embedding model using the features




  [Hello cu-cat notebook](https://github.com/dcolinmorgan/grph/blob/main/Hello_cu_cat.ipynb) goes in-depth on how to identify and deal with messy data using the **cu-cat** library.

  **CPU v GPU Biological Demos:**
  - Single Cell analysis [generically](https://github.com/dcolinmorgan/grph/blob/main/single_cell_umap_before_gpu.ipynb) and Single Cell analysis [accelerated by **cu-cat**](https://github.com/dcolinmorgan/grph/blob/main/single_cell_after_gpu.ipynb)

  - Chemical Mapping [generically](https://github.com/dcolinmorgan/grph/blob/main/generic_chemical_mappings.ipynb) and Chemical Mapping [accelerated with **cu-cat**](https://github.com/dcolinmorgan/grph/blob/main/accelerating_chemical_mappings.ipynb)

  - Metagenomic Analysis [generically](https://github.com/dcolinmorgan/grph/blob/main/generic_metagenomic_demo.ipynb) and Metagenomic Analysis [accelerated with **cu-cat**](https://github.com/dcolinmorgan/grph/blob/main/accelerating_metagenomic_demo.ipynb)




  Major dependencies the cuml and cudf libraries, as well as [standard
  python
  libraries](https://github.com/skrub-data/skrub/blob/main/setup.cfg)



  dirty_cat is now rebranded as part of the sklearn family as
  [skrub](https://github.com/skrub-data/skrub)


pkgId: 10449d87ddff634018b28bf177e806727c673c29126f264e5488a9e61eebb08d
name: python-cuallee
arch: src
version: 0.14.1
epoch: 0
release: 1
url: https://github.com/canimus/cuallee
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuallee-0.14.1-1.src.rpm
checksum_type: sha256
summary:
  Python library for data validation on DataFrame APIs including Snowflake/Snowpark, Apache/PySpark and Pandas/DataFrame.

description:
  ![snowflake](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/snowflake.svg?raw=true "Snowpark DataFrame API")| `snowpark` | `1.11.1`, `1.4.0`
  ![databricks](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/databricks.svg?raw=true "PySpark DataFrame API")| `pyspark` & `spark-connect` |`3.5.x`, `3.4.0`, `3.3.x`, `3.2.x`
  ![bigquery](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/bigquery.png?raw=true "BigQuery Client API")| `bigquery` | `3.4.1`
  ![pandas](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/pandas.svg?raw=true "Pandas DataFrame API")| `pandas`| `2.0.2`, `1.5.x`, `1.4.x`
  ![duckdb](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/duckdb.png?raw=true "DuckDB API")|`duckdb` | `1.0.0`, ~~`0.10.2`~~,~~`0.9.2`~~,~~`0.8.0`~~
  ![polars](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/polars.svg?raw=true "Polars API")|`polars`| `1.0.0`, ~~`0.19.6`~~
  ![daft](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/daft.png?raw=true "Daft API")|`daft`| `0.2.24`, ~~`0.2.19`~~
   <sub>Logos are trademarks of their own brands.</sub>

  ```bash
  pip install cuallee
  ```

  The most common checks for data integrity validations are `completeness` and `uniqueness` an example of this dimensions shown below:
  ```python
  from cuallee import Check, CheckLevel # WARN:0, ERR: 1

  check = Check(CheckLevel.WARNING, "Completeness")
  (
      check
      .is_complete("id")
      .is_unique("id")
      .validate(df)
  ).show() # Returns a pyspark.sql.DataFrame
  ```

  Perhaps one of the most useful features of `cuallee` is its extensive number of checks for `Date` and `Timestamp` values. Including, validation of ranges, set operations like inclusion, or even a verification that confirms `continuity on dates` using the `is_daily` check function.
  ```python

  check = Check(CheckLevel.WARNING, "CheckIsBetweenDates")
  df = spark.sql(
      """
      SELECT
          explode(
              sequence(
                  to_date('2022-01-01'),
                  to_date('2022-01-10'),
                  interval 1 day)) as date
      """)
  assert (
      check.is_between("date", ("2022-01-01", "2022-01-10"))
      .validate(df)
      .first()
      .status == "PASS"
  )
  ```

  Other common test is the validation of `list of values` as part of the multiple integrity checks required for better quality data.
  ```python
  df = spark.createDataFrame([[1, 10], [2, 15], [3, 17]], ["ID", "value"])
  check = Check(CheckLevel.WARNING, "is_contained_in_number_test")
  check.is_contained_in("value", (10, 15, 20, 25)).validate(df)
  ```

  When it comes to the flexibility of matching, regular expressions are always to the rescue. `cuallee` makes use of the regular expressions to validate that fields of type `String` conform to specific patterns.
  ```python
  df = spark.createDataFrame([[1, "is_blue"], [2, "has_hat"], [3, "is_smart"]], ["ID", "desc"])
  check = Check(CheckLevel.WARNING, "has_pattern_test")
  check.has_pattern("desc", r"^is.*t$") # only match is_smart 33% of rows.
  check.validate(df).first().status == "FAIL"
  ```

  Statistical tests are a great aid for verifying anomalies on data. Here an example that shows that will `PASS` only when `40%` of data is inside the interquartile range
  ```python
  df = spark.range(10)
  check = Check(CheckLevel.WARNING, "IQR_Test")
  check.is_inside_interquartile_range("id", pct=0.4)
  check.validate(df).first().status == "PASS"
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |id |timestamp          |check|level  |column|rule                         |value|rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |1  |2022-10-19 00:09:39|IQR  |WARNING|id    |is_inside_interquartile_range|10000|10  |4         |0.6      |0.4           |PASS  |
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  ```

  Besides the common `citizen-like` checks, `cuallee` offers out-of-the-box real-life checks. For example, suppose that you are working __SalesForce__ or __SAP__ environment. Very likely your business processes will be driven by a lifecycle:
  - `Order-To-Cash`
  - `Request-To-Pay`
  - `Inventory-Logistics-Delivery`
  - Others.
   In this scenario, `cuallee` offers the ability that the sequence of events registered over time, are according to a sequence of events, like the example below:
   ```python
  import pyspark.sql.functions as F
  from cuallee import Check, CheckLevel
  data = pd.DataFrame({
      "name":["herminio", "herminio", "virginie", "virginie"],
      "event":["new","active", "new", "active"],
      "date": ["2022-01-01", "2022-01-02", "2022-01-03", "2022-02-04"]}
      )
  df = spark.createDataFrame(data).withColumn("date", F.to_date("date"))


  check = Check(CheckLevel.WARNING, "WorkflowViolations")

  check.has_workflow("name", "event", "date", [("new", "active")], pct=0.5)
  check.validate(df).show(truncate=False)
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |id |timestamp          |check             |level  |column                   |rule        |value               |rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |1  |2022-11-07 23:08:50|WorkflowViolations|WARNING|('name', 'event', 'date')|has_workflow|(('new', 'active'),)|4   |2.0       |0.5      |0.5           |PASS  |
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
   ```

  `[2023-12-28]` ✨ __New feature!__ to simplify the entire validation of a dataframe in a particular dimension.
  ```python
  import pandas as pd
  from cuallee import Control
  df = pd.DataFrame({"X":[1,2,3], "Y": [10,20,30]})

  Control.completeness(df)
  ```

  In the `test` folder there are `docker` containers with the requirements to match the tests. Also a `perftest.py` available at the root folder for interests.
  ```

  cuallee: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 162.00
  pydeequ: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 322.00
  ```

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 494cfe1b43b208b851b3261da53ccda58db8ecc0a61544519f01f04bb8e2d6ed
name: python-cuallee
arch: src
version: 0.15.0
epoch: 0
release: 1
url: https://github.com/canimus/cuallee
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuallee-0.15.0-1.src.rpm
checksum_type: sha256
summary:
  Python library for data validation on DataFrame APIs including Snowflake/Snowpark, Apache/PySpark and Pandas/DataFrame.

description:
  ![snowflake](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/snowflake.svg?raw=true "Snowpark DataFrame API")| `snowpark` | `1.11.1`, `1.4.0`
  ![databricks](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/databricks.svg?raw=true "PySpark DataFrame API")| `pyspark` & `spark-connect` |`3.5.x`, `3.4.0`, `3.3.x`, `3.2.x`
  ![bigquery](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/bigquery.png?raw=true "BigQuery Client API")| `bigquery` | `3.4.1`
  ![pandas](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/pandas.svg?raw=true "Pandas DataFrame API")| `pandas`| `2.0.2`, `1.5.x`, `1.4.x`
  ![duckdb](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/duckdb.png?raw=true "DuckDB API")|`duckdb` | `1.0.0`, ~~`0.10.2`~~,~~`0.9.2`~~,~~`0.8.0`~~
  ![polars](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/polars.svg?raw=true "Polars API")|`polars`| `1.0.0`, ~~`0.19.6`~~
  ![daft](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/daft.png?raw=true "Daft API")|`daft`| `0.2.24`, ~~`0.2.19`~~
   <sub>Logos are trademarks of their own brands.</sub>

  ```bash
  pip install cuallee
  ```

  The most common checks for data integrity validations are `completeness` and `uniqueness` an example of this dimensions shown below:
  ```python
  from cuallee import Check, CheckLevel # WARN:0, ERR: 1

  check = Check(CheckLevel.WARNING, "Completeness")
  (
      check
      .is_complete("id")
      .is_unique("id")
      .validate(df)
  ).show() # Returns a pyspark.sql.DataFrame
  ```

  Perhaps one of the most useful features of `cuallee` is its extensive number of checks for `Date` and `Timestamp` values. Including, validation of ranges, set operations like inclusion, or even a verification that confirms `continuity on dates` using the `is_daily` check function.
  ```python

  check = Check(CheckLevel.WARNING, "CheckIsBetweenDates")
  df = spark.sql(
      """
      SELECT
          explode(
              sequence(
                  to_date('2022-01-01'),
                  to_date('2022-01-10'),
                  interval 1 day)) as date
      """)
  assert (
      check.is_between("date", ("2022-01-01", "2022-01-10"))
      .validate(df)
      .first()
      .status == "PASS"
  )
  ```

  Other common test is the validation of `list of values` as part of the multiple integrity checks required for better quality data.
  ```python
  df = spark.createDataFrame([[1, 10], [2, 15], [3, 17]], ["ID", "value"])
  check = Check(CheckLevel.WARNING, "is_contained_in_number_test")
  check.is_contained_in("value", (10, 15, 20, 25)).validate(df)
  ```

  When it comes to the flexibility of matching, regular expressions are always to the rescue. `cuallee` makes use of the regular expressions to validate that fields of type `String` conform to specific patterns.
  ```python
  df = spark.createDataFrame([[1, "is_blue"], [2, "has_hat"], [3, "is_smart"]], ["ID", "desc"])
  check = Check(CheckLevel.WARNING, "has_pattern_test")
  check.has_pattern("desc", r"^is.*t$") # only match is_smart 33% of rows.
  check.validate(df).first().status == "FAIL"
  ```

  Statistical tests are a great aid for verifying anomalies on data. Here an example that shows that will `PASS` only when `40%` of data is inside the interquartile range
  ```python
  df = spark.range(10)
  check = Check(CheckLevel.WARNING, "IQR_Test")
  check.is_inside_interquartile_range("id", pct=0.4)
  check.validate(df).first().status == "PASS"
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |id |timestamp          |check|level  |column|rule                         |value|rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |1  |2022-10-19 00:09:39|IQR  |WARNING|id    |is_inside_interquartile_range|10000|10  |4         |0.6      |0.4           |PASS  |
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  ```

  Besides the common `citizen-like` checks, `cuallee` offers out-of-the-box real-life checks. For example, suppose that you are working __SalesForce__ or __SAP__ environment. Very likely your business processes will be driven by a lifecycle:
  - `Order-To-Cash`
  - `Request-To-Pay`
  - `Inventory-Logistics-Delivery`
  - Others.
   In this scenario, `cuallee` offers the ability that the sequence of events registered over time, are according to a sequence of events, like the example below:
   ```python
  import pyspark.sql.functions as F
  from cuallee import Check, CheckLevel
  data = pd.DataFrame({
      "name":["herminio", "herminio", "virginie", "virginie"],
      "event":["new","active", "new", "active"],
      "date": ["2022-01-01", "2022-01-02", "2022-01-03", "2022-02-04"]}
      )
  df = spark.createDataFrame(data).withColumn("date", F.to_date("date"))


  check = Check(CheckLevel.WARNING, "WorkflowViolations")

  check.has_workflow("name", "event", "date", [("new", "active")], pct=0.5)
  check.validate(df).show(truncate=False)
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |id |timestamp          |check             |level  |column                   |rule        |value               |rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |1  |2022-11-07 23:08:50|WorkflowViolations|WARNING|('name', 'event', 'date')|has_workflow|(('new', 'active'),)|4   |2.0       |0.5      |0.5           |PASS  |
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
   ```

  `[2024-09-28]` ✨ __New feature!__ Return a simple `true|false` as a unified result for your `check`
  ```python
  import pandas as pd
  from cuallee import Check
  df = pd.DataFrame({"X":[1,2,3]})

  assert Check().is_complete("X").ok(df)
  ```

  Simplify the entire validation of a dataframe in a particular dimension.
  ```python
  import pandas as pd
  from cuallee import Control
  df = pd.DataFrame({"X":[1,2,3], "Y": [10,20,30]})

  Control.completeness(df)
  ```

  In the `test` folder there are `docker` containers with the requirements to match the tests. Also a `perftest.py` available at the root folder for interests.
  ```

  cuallee: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 162.00
  pydeequ: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 322.00
  ```

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 9b5fdc412400707d6c3e131194a34ae95752290d9979023620019622704e81b5
name: python-cube-http-client
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Pythonic HTTP client for Cube.js REST API (sync + async)
url: https://github.com/mharrisb1/cube-http-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cube-http-client-0.3.7-1.src.rpm
checksum_type: sha256
description:
  Pythonic HTTP client for [Cube.dev](https://cube.dev) REST API (sync + async support)



  [![PyPI version](https://badge.fury.io/py/cube-http-client.svg)](https://badge.fury.io/py/cube-http-client)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cube-http-client.svg)](https://pypi.org/project/cube-http-client)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/cube-http-client)](https://pypi.org/project/cube-http-client/)

  Available on [PyPI](https://pypi.org/project/cube-http-client)

  ```bash
  pip install cube-http-client
  ```



  ```python
  import cube_http

  cube = cube_http.Client({"url": "...", "token": "..."})


  meta = cube.v1.meta()


  results = cube.v1.load({
      "measures": ["..."],
      "dimensions": ["..."],
  })


  compiled_sql = cube.v1.sql({
      "measures": ["..."],
      "dimensions": ["..."],
  })
  ```



  | Endpoint                    | Description                                                                                                                                                               | Supported? |
  | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
  | `/v1/load`                  | Get the data for a query.                                                                                                                                                 | ✅         |
  | `/v1/sql`                   | Get the SQL Code generated by Cube to be executed in the database.                                                                                                        | ✅         |
  | `/v1/meta`                  | Get meta-information for cubes and views defined in the data model. Information about cubes and views with `public: false` will not be returned.                          | ✅         |
  | `/v1/run-scheduled-refresh` | Trigger a scheduled refresh run to refresh pre-aggregations.                                                                                                              | ❌         |
  | `/v1/pre-aggregations/jobs` | Trigger pre-aggregation build jobs or retrieve statuses of such jobs.                                                                                                     | ❌         |
  | `/readyz`                   | Returns the ready state of the deployment.                                                                                                                                | ❌         |
  | `/livez`                    | Returns the liveness state of the deployment. This is confirmed by testing any existing connections to dataSource. If no connections exist, it will report as successful. | ❌         |





  ```python
  import cube_http

  cube = cube_http.Client(...)
  ```



  ```python
  import cube_http

  cube = cube_http.AsyncClient(...)
  ```



  Error classes are available for each endpoint. For example, handling an API error when calling `/v1/meta` endpoint:

  ```python
  import cube_http
  from cube_http.exc.v1 import V1MetaError

  cube = cube_http.Client(...)

  try:
      meta = cube.v1.meta()
  except V1MetaError as e:
      print(e)
  ```


pkgId: 1f0eeaac124709213515704428fe0f1ae71b1f9b35da6ed36476401b5c934a30
name: python-cubed
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: Scalable out-of-core array processing in Python
url: https://pypi.org/project/cubed/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubed-0.19.0-1.src.rpm
checksum_type: sha256
description:
  Cubed is a Python library for scalable out-of-core multi-dimensional array processing with bounded memory.

  - Cubed provides NumPy and Xarray APIs for processing your multi-dimensional array data
  - Cubed is a drop-in replacement for Dask's Array API
  - Cubed will tell you if your computation would run out of memory *before* running it
  - Cubed is designed to be robust to failures and will reliably complete a computation
  - Cubed can process hundreds of GB of array data on your laptop using all available cores
  - Cubed is horizontally scalable and stateless, and can scale to multi-TB datasets in the cloud

  [Documentation](https://cubed-dev.github.io/cubed/)


pkgId: d0c1e7299a515362331b4a32c63df15c3662499f011b92827e06a5ce18ad2673
name: python-cubedtube
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: A video viewing webapp that organizes videos into channels and series
url: https://github.com/stevarino/cubed-tube
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubedtube-0.1.20-1.src.rpm
checksum_type: sha256
description:
  CubedTube is a webapp video viewer focused on three aspects: time, creator
  (channel), and series (or seasons). This makes it possible for viewers to
  seamlessly bounce between different creators while watching a series unfold,
  discovering new creators involved in the series and watching the story unfold
  with the creators together.

  It's basically a YouTube playlist multiplexer.

  CubedTube started off as [hermit.tube](https://hermit.tube) (
  [git repo](https://github.com/stevarino/hermit-tube)) - a way to watch
  all of the [HermitCraft](http://hermitcraft.com) seasons and follow your hermits
  in order. However as the project developed and I became more familiar with the
  YouTube space, a general solution seemed ideal.

  Want to build your own? [Check out the tutorial!](https://github.com/stevarino/cubed-tube/blob/master/docs/tutorial.md)



  The first reason I created this site was I wanted to easily watch a HermitCraft
  season in order while bouncing between series.

  The second was I wanted to build a low-dependency, simple, and understandable
  web app. I decided to make the actual content static to simplify hosting (and
  as an extra challenge). But this is built with minimal requirements, consisting
  of [peewee](https://github.com/coleifer/peewee) as a database ORM, the awesome
  [Pako](https://nodeca.github.io/pako/) library for some data compression magic,
  and a dynamic image-loader javascript library to make sure we don't DDOS
  YouTube.

  An important factor of this project is that the code remains understandable and
  approachable for those learning this craft. If you find this site helpful or
  have any questions, I would love to hear from you.



   - Watch videos in chronological order across several channels.
   - Videos are automatically queued for uninterrupted watching.
   - Stored progress across subsequent loads, both through local storage and
     through the cloud.
   - Watch a select set of channels through multiple profiles.
   - Easily swap between profiles without losing your place.
   - Desktop and mobile friendly!
   - Installable as an app (pwa).
   - Modular footprint - the webapp can be run as a standalone HTML website,
     optionally with a Flask app for OAuth and Cloud Storage, optional
     memcached support, and optional backend worker for async cloud writes.



   - Cross platform video viewing (youtube/twitch/etc).
   - Promotion videos between videos (livestream announcements, events, etc)
   - Better CSS/Theming support.


pkgId: f8d2dc60bb584253405fa46ac6823d195e6e6dee9735235c82f7094a3f1f08c8
name: python-cubemap2pano
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Convert cubemap to equirectangular panorama image
url: https://github.com/xrleader/cubemap2pano
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubemap2pano-0.0.4-1.src.rpm
checksum_type: sha256
description:
  `cubemap2pano`는 큐브맵 이미지를 등각 원통형 파노라마 이미지로 변환하는 Python 패키지입니다.



  ```bash
  pip install cubemap2pano
  ```



  다음은 `cubemap2pano` 패키지를 사용하는 예제입니다:

  ```python

  from cubemap2pano import cubemap2pano

  if __name__ == "__main__":
      HEIGHT = 1024
      WIDTH = HEIGHT * 2

      cubemap_paths = [
          ([ "./F.jpg", "./R.jpg", "./B.jpg", "./L.jpg", "./U.jpg", "./D.jpg"], "./result/pano.jpg")
      ]
      cubemap2pano(WIDTH, HEIGHT, cubemap_paths)
  ```


pkgId: d6dd4a69fdfbdbbc40a315d2b8becb2406f3dcbe08a304248a0380e9f598600e
name: python-cubes
arch: src
version: 1.1
epoch: 0
release: 1
summary: Lightweight framework for Online Analytical Processing (OLAP) and multidimensional analysis
description: UNKNOWN
url: http://cubes.databrewery.org
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubes-1.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT license with following addition: If your version of the Software supports interaction with it remotely through a computer network, the above copyright notice and this permission notice shall be accessible to all users.


pkgId: 5749c141a59144f4d030fd10d22437237bdab506afa55786f0a3ca03afc98845
name: python-cubestat
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Horizon chart in terminal for system monitoring
url: https://github.com/okuvshynov/cubestat
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubestat-0.3.1-1.src.rpm
checksum_type: sha256
description:
  Horizon chart in terminal. Supports CPU/GPU/ANE/RAM/swap/IO monitoring for Apple M1/M2/M3, nVidia GPUs


pkgId: 9c094f712d6c388d77a85fdc852031ee4cda8276783f69ca00f37547ac02d69d
name: python-cubetools
arch: src
version: 0.8.8
epoch: 0
release: 1
summary: CubeAI模型开发常用工具集
url: https://openi.pcl.ac.cn/cubeai/cubetools
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubetools-0.8.8-1.src.rpm
checksum_type: sha256
description:
  [CubeAI智立方](https://openi.pcl.ac.cn/openi/cubeai) 模型和应用开发常用工具集。

  目前主要包括：

  - 图像前处理、后处理等常用函数封装。
  - 通用AI流媒体在线推理服务框架。
  - 通用OpenVino模型推理框架（基于 [OpenVino Runtime](https://pypi.org/project/openvino/) 封装）。
  - 通用ONNX模型推理框架（基于 [ONNX Runtime](https://pypi.org/project/onnxruntime-gpu/) 封装）。
  - 通用PaddlePaddle模型推理框架（基于 [Paddle Inference](https://www.paddlepaddle.org.cn/paddle/paddleinference) 推理引擎封装）。
  - 通用MindSporeLite推理框架（基于 [MindSpore Lite](https://www.mindspore.cn/lite) 推理引擎封装）。
  - 通用Pytorch模型推理框架。
  - 基于Gradio的视频流媒体类Python前端服务组件。
  - 基于Gradio的聊天对话类Python前端服务组件。
  - HuggingFace模型和数据集下载。
  - ModelScope模型下载。
  - 模型文件下载。



  - https://openi.pcl.ac.cn/cubeai/cubetools



  - https://pypi.org/project/cubetools



      pip install cubetools -i https://pypi.tuna.tsinghua.edu.cn/simple



  - [CubeAI模型示范库](https://openi.pcl.ac.cn/cubeai-model-zoo/cubeai-model-zoo)


pkgId: 4b4ae3b52cb676a9e508e2f8a1e232384ba47dd568b169111246136d0a9f21e0
name: python-cubic-bezier-spline
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://pypi.org/project/cubic-bezier-spline/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubic-bezier-spline-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  Approximate or interpolate a sequence of points into a sequence of c2-continuous, non-rational cubic Bézier curves.

description:
  This package exists mostly to create C2-continuous, non-rational cubic Bezier splines. In other words, this will approximate or interpolate a sequence of points into a sequence of non-rational cubic Bezier curves.

  Should be relatively fast, but this isn't suited for heavy math. This is for taking some points you have and making a nice-looking curve out of them. Specifically, a cubic Bezier spline, which is made from the type of curves used in SVG, fonts, and other vector-base programs. I am only interested in feature requests that directly apply to that purpose. This is not an exercise in completism.



      pip install cubic_bezier_spline



  * Evaluate, differentiate, elevate, and split non-rational Bezier curves of any degree
  * Construct non-rational cubic Bezier splines (open and closed, approximating and interpolating)
  * Evaluate and differentiate non-rational Bezier splines of any degree



  * Work with rational Bezier splines, b-splines, NURBS, or any other generalization of Bezier curves
  * Decrease curve degree
  * Approximate curve intersections
  * Approximate the length of a curve
  * "Stroke" (move left or right) a curve<br/>

  ** much of the "will not" features can be found here: https://github.com/dhermes/bezier



      
      new_open_approximating_spline([(x0, y0), (x1, y1), ...])

      
      new_closed_approximating_spline([(x0, y0), (x1, y1), ...])

      
      new_open_interpolating_spline([(x0, y0), (x1, y1), ...])

      
      new_closed_interpolating_spline([(x0, y0), (x1, y1), ...])

  Any of these will return a BezierSpline object. This object has a some of the usual methods (e.g., elevate, derivative, split) to help find path normals or do some light modeling, but you may be most interested in.

      
      
      spline(time: float)

      
      
      spline.svg_data



  Some of these use double and triple repeated points to create "knots". This isn't a special function, just a feature of Bezier math. The idea is clearer with a picture.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="doc/test_knot_dark.png">
    <source media="(prefers-color-scheme: light)" srcset="doc/test_knot_light.png">
    <img alt="knot examples" src="doc/test_knot_dark.png">
  </picture>



  * A Primer on Bezier Curves<br/>
  https://pomax.github.io/bezierinfo/
  * UCLS-Math-149-Mathematics-of-Computer-Graphics-lecture-notes<br/>
  https://www.stkent.com/assets/pdfs/UCLA-Math-149-Mathematics-of-Computer-Graphics-lecture-notes.pdf


pkgId: f35958d7d85f818020129818275a7aec1e4eb0fdf51536e869c99a8916ee9e37
name: python-cubicweb
arch: src
version: 4.8.0
epoch: 0
release: 1
summary: a repository of entities / relations for knowledge management
url: https://www.cubicweb.org
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-4.8.0-1.src.rpm
checksum_type: sha256
description:
  CubicWeb is a entities / relations based knowledge management system
  developped at Logilab.
  This package contains:
  - a repository server
  - a RQL command line client to the repository
  - an adaptative modpython interface to the server
  - a bunch of other management tools
  |pipeline status| |pypi downloads| |pypi license| |docker pulls|
  Intranet links to internal Sonarqube :  https://sonarqube.k.intra.logilab.fr/dashboard?id=cubicweb-cubicweb
  |Quality Gate Status| |Reliability Rating| |Security Rating| |Technical Debt| |Vulnerabilities|


pkgId: 1f57ae6477d0a5aeb3073eb398b5ab59d5655e3ba64c23abb4fa1a3129a75241
name: python-cubicweb-addressbook
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: address book component for the CubicWeb framework
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-addressbook
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-addressbook-2.0.2-1.src.rpm
checksum_type: sha256
description:
  The addressbook cube adds a phone number, postal address and instant
  messenger address (supports icq, msn and jabber) to the schema.


pkgId: a95c852f3e3b07952a631c432a0822ad66282a9cc87f09dffe51632f141f13fe
name: python-cubicweb-api
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: This cube is the new api which will be integrated in CubicWeb 4.
url: https://forge.extranet.logilab.fr/cubicweb/cubes/api
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-api-0.16.0-1.src.rpm
checksum_type: sha256
description:
  This cube exposes the new api, replacing the `RQLController cube`_ with a simpler architecture.
  We plan on integrating this new API directly into CubicWeb, without having to rely on this cube.
  You can use the `CubicWebJS`_ client to communicate with this API in JavaScript.
  See the project `React Admin CubicWeb`_ for an example on how to use `CubicWebJS`_.
  **⚠️ Please note this cube will later be integrated into CubicWeb.
  The installation instructions only applies for the API cube while it lives in its own repository.**


pkgId: a0e362274d9f5977c0cc9585250fe6f57eefc247070aa257aa5c2a27b029cb25
name: python-cubicweb-blog
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: blogging component for the CubicWeb framework
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-blog
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-blog-3.0.0-1.src.rpm
checksum_type: sha256
description:
  The `blog` cube provides blogging functionnalities. It creates two entity types,
  `Blog` and `BlogEntry`. There are related to each other by the relation
  `BlogEntry entry_of Blog`.
  It is a CubicWeb component. CubicWeb is a semantic web application
  framework, see http://www.cubicweb.org


pkgId: cc238c1a8121f44cddcef6e89af532af8f2ebb9441ac7dd52dc5ccb602d8d0bb
name: python-cubicweb-card
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: card/wiki component for the CubicWeb framework
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-card
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-card-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This cube models cards that are like wiki pages.

  `Card` entities have a title, an abstract and some textual content as text, rest
  or html.

  To create a new card, just create a link like '/card/YOUR_WIKI_ID' and follow it
  in your browser. Such a link can be written using the native HTML editor
  (fckeditor) or the dedicated restructured text "card" directive, as follows ::

    :card:`free_software/logilab:free software at Logilab`


pkgId: de0932dc5dbfe1e3549b6b3e0e3943b469c3c85b7e97add148f178fe7e06247a
name: python-cubicweb-comment
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: commenting system for the CubicWeb framework
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-comment
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-comment-3.0.0-1.src.rpm
checksum_type: sha256
description:
  The `comment` cube provides threadable comments feature.
  It is a CubicWeb component. CubicWeb is a semantic web application
  framework, see http://www.cubicweb.org


pkgId: df70d4119534cc02e10961ace4add49ab09119f590d33d270a4ae10b2d5dd266
name: python-cubicweb-elasticsearch
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Simple ElasticSearch indexing integration for CubicWeb
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-elasticsearch
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-elasticsearch-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Simple ElasticSearch indexing integration for CubicWeb
  Parameters
  ~~~~~~~~~~
  * elasticsearch-locations (CW_ELASTICSEARCH_LOCATIONS)
  * index-name (CW_INDEX_NAME)
  * elasticsearch-verify-certs (CW_ELASTICSEARCH_VERIFY_CERTS)
  * elasticsearch-ssl-show-warn (CW_ELASTICSEARCH_SSL_SHOW_WARN)
  Pyramid debug panel
  ~~~~~~~~~~~~~~~~~~~
  To activate the debug panel, you'll need to install ``pyramid_debugtoolbar``,
  typically with::
    pip install pyramid_debugtoolbar
  Then, you'll have activate the debug toolbar and include the ElasticSearch
  panel in your ``pyramid.ini``:
    pyramid.includes =
        pyramid_debugtoolbar
    debugtoolbar.includes =
        cubicweb_elasticsearch.pviews.espanel
  **Alltext** field
  ~~~~~~~~~~~~~~~~~~
  The `cubicweb_elasticsearch.search_helpers.compose_search` referencies
  a custom `alltext` field which contains all indexed text. This field  must be
  defined in the custom Indexer mapping.


pkgId: 8c7b4fece878f21dbb08e02e9aab961723dfba6565c6d29e3f3d4a2013c90b2c
name: python-cubicweb-oauth2
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Oauth2/OpenID authentication for cubicweb
url: http://www.cubicweb.org/project/cubicweb-oauth2
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-oauth2-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Oauth2/OpenID connect authentication client for cubicweb.
  All configuration is done in `all-in-one.conf`. Defaults values should work
  fine with Keycloak, for other provider refer to the documentation of the
  content of the JWT token.
  * `oauth2-enabled` should be set to `yes` once it is configured
  * `oauth2-client-id` and `oauth2-client-secret` should be set (given by the
    provider).
  * For OpenID connect providers `oauth2-server-url` can be set. For keycloak it
    is https://<server>/auth/realms/<realm>. The configuration is then obtained
    from the metadata url /.well-known/openid-configuration
  * If you want to avoid a request to the metadata url, or if your provider
    doesn't implement OpenID, you should to configure `oauth2-authorization-url`,
    `oauth2-token-url` and `oauth2-jwk-path`.
  * `oauth2-token-login` is used to map a field of the JWT token with CubicWeb
    login.
  * On the provider side, the callback url should be configured to
    https://<cubicweb>/oauth2/callback
  At this point you should be able to log in an existing user through the login
  page using the "Log in with Oauth2" button.
  If you want to automatically register new users, you must set
  `oauth2-register-user` to `yes` and configure `oauth2-default-group`,
  `oauth2-token-firstname`, `oauth2-token-surname` and `oauth2-token-email`.
  If your instance only accepts users from the Oauth2 provider, you can set
  `oauth2-auto-login` which skip the login page and start oauth2 authentication
  directly.
  If your instance require authenticated users from Oauth2 provider only, you
  can set `oauth2-force-login` to `yes`, this will redirect all unauthenticated
  requests to oauth2 login.


pkgId: c592af265d18225edf11f935a773956aab58a4c027b85326efbde4c3184d438f
name: python-cubicweb-rqlcontroller
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: restfull rql edition capabilities
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-rqlcontroller
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-rqlcontroller-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Controller that gives users rql read/ write capabilities. To have token
  authentication, install `cubicweb_signedrequest <https://forge.extranet.logilab.fr/cubicweb/cubes/signedrequest>`_.


pkgId: 0486c0b20e2ec40a5f30160f45ceb5f291a22795068695cbbcff66123b7a4598
name: python-cubicweb-seda
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Data Exchange Standard for Archival
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-seda
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-seda-2.4.1-1.src.rpm
checksum_type: sha256
description:
  This cube implements the SEDA_ standard for CubicWeb. It has been funded by the
  SIAF_ and the `SAEM project`_.
  Project is hosted at https://www.cubicweb.org/project/cubicweb-seda/ and source
  code at https://hg.logilab.org/master/cubes/seda.
  To launch the tests::
    python -m tox
  To generate the documentation::
    python -m tox -e doc
  Part of the code is generated from SEDA 2's XSD schema. If you update the schema
  or code generator (on of the `cubicweb_seda/xsd*.py` files), to update the
  generated code type::
    python -m tox -e make


pkgId: 854a50656a231ebe92a658fa8d53f57c955f41fc972922c3681e3eb183f510e0
name: python-cubicweb-signedrequest
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: REST API for CubicWeb
url: https://forge.extranet.logilab.fr/cubicweb/cubes/cubicweb-signedrequest
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-signedrequest-3.1.0-1.src.rpm
checksum_type: sha256
description:
  This cube allows a client to forge signed HTTP resquests that are then
  recognized as valid by the CubicWeb web server, ie. the request is
  handled as an authenticated user. For example, it can be used to start
  an operation using an authenticated user.
  It's usually used alongside with cubicweb-rqlcontroller_ and
  cwclientlib_.
  This cube aims at make it easy to write REST-like APIs for CW.
  Long story short: cubicweb-signedrequest_ allows you to make
  authenticated HTTP requests simply by addind a properly forged HTTP
  header in your request.
               your request will be refused is the ``Date`` header if
               not very accurate. Also, for security reasons, you won't
               have any detail on why your request has been denied.


pkgId: fc9693fa1f808fe36e0f45af301d791cc60e6e0d26bb82dde376907e6ef30769
name: python-cubicweb-timesheet
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: record who did what and when for the CubicWeb framework
url: http://www.cubicweb.org/project/cubicweb-timesheet
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-timesheet-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This cube is for tracking resource availability and usage (persons and their
  daily activities, meeting rooms and their occupancy, etc.).


pkgId: f441bcfb14b8bba435fa4e44350c8610e876637492ed0ecb6ffd367d58981f87
name: python-cubicweb-web
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Legacy component for web application
url: https://forge.extranet.logilab.fr/cubicweb/cubes/web
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubicweb-web-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This cube provides a dynamic view selection system. This system allows
  semi-automatic XHTML/XML/JSON/text generation, based on context.
  All this was once available in CubicWeb 3 as a `cubicweb.web` module.
  This code is still maintained, however we no longer add new features.


pkgId: 0f67cf31255ee5989bbeab1599e98b362fe57e62ec6b99e75d60b6a811e7ef20
name: python-cubo
arch: src
version: 2024.8.0
epoch: 0
release: 1
summary: On-Demand Earth System Data Cubes in Python
url: https://github.com/davemlz/cubo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cubo-2024.8.0-1.src.rpm
checksum_type: sha256
description:
  **GitHub**: [https://github.com/davemlz/cubo](https://github.com/davemlz/cubo)
  **Documentation**: [https://cubo.readthedocs.io/](https://cubo.readthedocs.io/)
  **PyPI**: [https://pypi.org/project/cubo/](https://pypi.org/project/cubo/)
  **Conda-forge**: [https://anaconda.org/conda-forge/cubo](https://anaconda.org/conda-forge/cubo)
  **Tutorials**: [https://cubo.readthedocs.io/en/latest/tutorials.html](https://cubo.readthedocs.io/en/latest/tutorials.html)


pkgId: 4fb6fe328aa4cda14e0aab52616455e47aadbb2c61c59fd30f4ec37fdefa038b
name: python-cucaracha
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Mr. Franz Cucaracha will be glad to assist you to the document analysis and processing routine
url: https://pypi.org/project/cucaracha/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cucaracha-0.1.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/acsenrafilho/cucaracha/refs/heads/main/docs/assets/cucaracha-logo.png" width=700>

  [![Documentation Status](https://readthedocs.org/projects/cucaracha/badge/?version=latest)](https://cucaracha.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/acsenrafilho/cucaracha/graph/badge.svg?token=TgmCLPoIbW)](https://codecov.io/gh/acsenrafilho/cucaracha)
  [![CI Main](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml/badge.svg?branch=main)](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml)
  [![CI Develop](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml/badge.svg?branch=develop)](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml)



  Inspired by Franz Kafka's infamous character, Gregor Samsa — an ordinary man who wakes up to find himself transformed into a cockroach in *The Metamorphosis*. Here, `cucaracha` embodies the metaphor of a tireless, sometimes bureaucratic helper working tirelessly in the background. In the digital age, Mr. Cucaracha is here to assist you with the complex and often tedious tasks of document processing and analysis.



  `cucaracha` is an open-source library crafted to help with digital document analysis and processing. It provides a toolkit for working with both structured and unstructured data, allowing users to collect, transform, and interpret textual content from various document formats, including PDFs and images.



  - **Text Extraction**: Efficiently retrieve text from PDFs and image files, transforming them into usable data.
  - **Content Structuring**: Process extracted text into structured formats, aiding in more organized data handling and downstream applications.
  - **Context Recognition**: Perform contextual analysis to interpret and label document content based on intended usage.

  The major objective of this project is to offer an accessible, open-source alternative for processing document files, which provides document processing and analysis algorithms to simplify tasks that would traditionally be time-consuming or challenging to automate.



  The name `cucaracha` reflects the tireless, behind-the-scenes nature of the tool. Like Kafka's transformed character, Mr. Cucaracha deals with the mundanity and bureaucracy often present in document processing tasks. He's designed to tackle these repetitive and complex tasks with minimal oversight, ensuring efficient and structured data extraction without the typical hurdles of document handling.



  Check out the [full documentation](https://cucaracha.readthedocs.io/en/latest/) for detailed instructions on how to use, implement, and keep up with updates to `cucaracha`.



  We welcome contributions to `cucaracha`! To get involved, take a look at the [open issues](https://github.com/acsenrafilho/cucaracha/issues) and join us in enhancing Mr. Cucaracha's capabilities. Whether you're here to fix bugs, suggest features, or work on documentation, your input is valuable to the project.

  Happy document processing with Mr. Cucaracha! 🪳



  A quick to use install is via `pip`, as follows:

  > [!NOTE]
  > The installation requires Python 3.9 or higher

  ```bash
  pip install cucaracha
  ```


pkgId: a0a04b80500c526644553f7f16250f6ec411e44a3528edf9b61a0c2d6c363fc6
name: python-cucaracha
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Mr. Franz Cucaracha will be glad to assist you to the document analysis and processing routine
url: https://pypi.org/project/cucaracha/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cucaracha-0.4.1-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/acsenrafilho/cucaracha/refs/heads/main/docs/assets/cucaracha-logo.png" width=700>

  [![Documentation Status](https://readthedocs.org/projects/cucaracha/badge/?version=main)](https://cucaracha.readthedocs.io/en/main/?badge=main)
  [![codecov](https://codecov.io/gh/acsenrafilho/cucaracha/graph/badge.svg?token=TgmCLPoIbW)](https://codecov.io/gh/acsenrafilho/cucaracha)
  [![CI Main](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml/badge.svg?branch=main)](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml)
  [![CI Develop](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml/badge.svg?branch=develop)](https://github.com/acsenrafilho/cucaracha/actions/workflows/ci-lib.yml)
  [![PyPI version](https://badge.fury.io/py/cucaracha.svg)](https://badge.fury.io/py/cucaracha)



  Inspired by Franz Kafka's infamous character, Gregor Samsa — an ordinary man who wakes up to find himself transformed into a cockroach in *The Metamorphosis*. Here, `cucaracha` embodies the metaphor of a tireless, sometimes bureaucratic helper working tirelessly in the background. In the digital age, Mr. Cucaracha is here to assist you with the complex and often tedious tasks of document processing and analysis.



  `cucaracha` is an open-source library crafted to help with digital document analysis and processing. It provides a toolkit for working with both structured and unstructured data, allowing users to collect, transform, and interpret textual content from various document formats, including PDFs and images.



  - **Text Extraction**: Efficiently retrieve text from PDFs and image files, transforming them into usable data.
  - **Content Structuring**: Process extracted text into structured formats, aiding in more organized data handling and downstream applications.
  - **Context Recognition**: Perform contextual analysis to interpret and label document content based on intended usage.

  The major objective of this project is to offer an accessible, open-source alternative for processing document files, which provides document processing and analysis algorithms to simplify tasks that would traditionally be time-consuming or challenging to automate.

  Check it out all the public datasets and ML models used in this project located at Kaggle - [Cucaracha Project](https://www.kaggle.com/organizations/cucaracha-project)



  The name `cucaracha` reflects the tireless, behind-the-scenes nature of the tool. Like Kafka's transformed character, Mr. Cucaracha deals with the mundanity and bureaucracy often present in document processing tasks. He's designed to tackle these repetitive and complex tasks with minimal oversight, ensuring efficient and structured data extraction without the typical hurdles of document handling.



  Check out the [full documentation](https://cucaracha.readthedocs.io/en/main/) for detailed instructions on how to use, implement, and keep up with updates to `cucaracha`.



  We welcome contributions to `cucaracha`! To get involved, take a look at the [open issues](https://github.com/acsenrafilho/cucaracha/issues) and join us in enhancing Mr. Cucaracha's capabilities. Whether you're here to fix bugs, suggest features, or work on documentation, your input is valuable to the project.

  Happy document processing with Mr. Cucaracha! 🪳



  A quick to use install is via `pip`, as follows:

  > [!NOTE]
  > The installation requires Python 3.9 or higher

  ```bash
  pip install cucaracha
  ```


pkgId: 620bf4db4aacb680c2e1b2f373780cdac73dda3504b6e3279f510d4888545fec
name: python-cucumber-expressions
arch: src
version: 17.1.0
epoch: 0
release: 1
summary: Cucumber Expressions - a simpler alternative to Regular Expressions
url: https://github.com/cucumber/cucumber-expressions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cucumber-expressions-17.1.0-1.src.rpm
checksum_type: sha256
description:
  [The main docs are here](https://github.com/cucumber/cucumber-expressions#readme).



  This project uses [Poetry](https://python-poetry.org/) as its build system.
  In order to develop on this project, please install Poetry as per your system's instructions on the link above.



  The test suite uses `pytest` as its testing Framework.




  In order to set up your dev environment, run the following command from this project's directory:

  ``` python
  poetry install
  ```
  It will install all package and development requirements, and once that is done it will do a dev-install of the source code.

  You only need to run it once, code changes will propagate directly and do not require running the install again.




  `pytest` automatically picks up files in the current directory or any subdirectories that have the prefix or suffix of `test_*.py`.
  Test function names must start with `test*`.
  Test class names must start with `Test*`.

  To run all tests:

  ``` python
  poetry run pytest
  ```


pkgId: 4b1296713daa5e3d8539d2cfa7024a872b22318f1e80bc82dbfb6fef2ad60a41
name: python-cucumber-tag-expressions
arch: src
version: 6.1.1
epoch: 0
release: 1
summary: Provides a tag-expression parser and evaluation logic for cucumber/behave
url: https://github.com/cucumber/tag-expressions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cucumber-tag-expressions-6.1.1-1.src.rpm
checksum_type: sha256
description:
  |badge.CI_status| |badge.latest_version| |badge.license| |badge.downloads|
  Cucumber tag-expressions for Python.
  |logo|
  Cucumber tag-expressions provide readable boolean expressions
  to select features and scenarios marked with tags in Gherkin files
  in an easy way::
      
      @a and @b
      @a or  @b
      not @a
      
      @a and not @b
      (@a or @b) and not @c
  SEE ALSO:
  * https://cucumber.io/docs/cucumber/api/#tag-expressions


pkgId: 7670bb43430a9c1de8a7cdb5479918b524edee9da8eec50138aa1623274fb4d8
name: python-cuda-guass-normal
arch: src
version: 1.13
epoch: 0
release: 1
summary: A package used in DNN trainning in ATLAS analysis
url: https://pypi.org/project/cuda-guass-normal/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuda-guass-normal-1.13-1.src.rpm
checksum_type: sha256
description:
  Python package use cuda to normalize input variables using cuda package in ATLAS analysis

  Function use to do Guassian Normalization:
  Mean:
  $$\mu_{i}=\frac{\sum x_{i}\times w_{i}}{\sum w_{i}}$$
  Variance:
  $$\sigma_{i}=\frac{\sum (x_{i}-\mu_{i})^{2}\times w_{i}}{\frac{N-1}{N}\times\sum w_{i}}$$
  Normalized input feature:
  $$\bar{x_{i}}=\frac{x_{i}-\mu_{i}}{\sigma_{i}}$$

  Main function: guass_normal((1),(2),(3))

  Input:

  (1):Numpy array contain all input features you want to normalize.
  (2):Numpy array used to calculate each feature's mean and variance.
  (3):1-d Numpy array contains each events weight in (2)

  (1) and (2) must have the same number of columns.

  cuda_cut((1),(2),(3)): Used to calculate event yield after applying DNN cut.

  Input:
  (1): 1-d numpy array include the variable  you want to cut.
  (2): 1-d numpy array include event weight.
  (3): cut threshold


pkgId: b1f503cda6c8f9a79f0bb9f99a901fdf2f8f1ff4150addc55545e063f9ba600e
name: python-cudaq
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Python bindings for the CUDA-Q toolkit for heterogeneous quantum-classical workflows.
url: https://developer.nvidia.com/cuda-q
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cudaq-0.9.0-1.src.rpm
checksum_type: sha256
description:
  CUDA-Q is a comprehensive framework for quantum programming. It features:

  - A programming model which extends C++ and Python with quantum kernels,
    enabling high-level programming in familiar languages
  - A high-performance quantum compiler, `nvq++`, based on the industry standard
    LLVM toolchain
  - Interoperability with all of the leading models and tools for accelerated
    computing, including CUDA, ISO standard parallelism, OpenMP, and OpenACC
  - The ability to utilize and seamlessly switch between different quantum
    technologies, including state-of-the-art simulator backends with NVIDIA
    cuQuantum and a number of different physical quantum processors (QPUs)

  The CUDA-Q Python wheels contain the Python API and core components of CUDA-Q.
  This package installs CUDA-Q binaries that are compatible with a CUDA version
  11.x (where x >= 8) or 12.x. More information about available packages as
  well as a link to the documentation and examples for each version can be found
  in the [release notes][cudaq_docs_releases]. System and compatibility
  requirements are listed in the Installation Guide of the linked documentation.

  **Note**: CUDA-Q is currently only supported on Linux operating systems using
  `x86_64` or `aarch64`/`arm64` processors.

  [cudaq_docs_releases]:
      https://nvidia.github.io/cuda-quantum/latest/releases.html



  [//]: # (Begin complete install)

  CUDA-Q does not require a GPU to use, but some components are GPU-accelerated.

  Getting started with CUDA-Q on `x86_64` platforms simply requires `pip install
  cudaq`. Please make sure your `pip` version is \>= 24.0.
  If you have an NVIDIA GPU on your host system, you will be
  able to use it without any further installation steps.

  > **Important:**
  > Please check if you have an existing installation of the `cuda-quantum`, `cudaq-quantum-cu11`, or `cuda-quantum-cu12` package, and uninstall it prior to installation. Different CUDA-Q binary distributions may conflict with each other causing issues.


  If you want to perform multi-GPU simulations, or if you are using
  `aarch64`/`arm64` processors, additional components must be installed. We
  recommend using [Conda](https://docs.conda.io/en/latest/) to do so. If you are
  not already using Conda, you can install a minimal version following the
  instructions [here](https://docs.anaconda.com/miniconda/). The following
  commands will create and activate a complete environment for CUDA-Q with all its
  dependencies:

  [//]: # (Begin conda install)

  ```console
  cuda_version=11.8.0 # set this variable to version 11.x (where x >= 8) or 12.x
  conda create -y -n cudaq-env python=3.11 pip
  conda install -y -n cudaq-env -c "nvidia/label/cuda-${cuda_version}" cuda
  conda install -y -n cudaq-env -c conda-forge mpi4py openmpi cxx-compiler
  conda env config vars set -n cudaq-env LD_LIBRARY_PATH="$CONDA_PREFIX/envs/cudaq-env/lib:$LD_LIBRARY_PATH"
  conda env config vars set -n cudaq-env MPI_PATH=$CONDA_PREFIX/envs/cudaq-env
  conda activate cudaq-env
  pip install cudaq
  source $CONDA_PREFIX/lib/python3.11/site-packages/distributed_interfaces/activate_custom_mpi.sh
  ```

  [//]: # (End conda install)

  You must configure MPI by setting the following environment variables:

  [//]: # (Begin ompi setup)

  ```console
  export OMPI_MCA_opal_cuda_support=true OMPI_MCA_btl='^openib'
  ```

  [//]: # (End ompi setup)

  *If you do not set these variables you may encounter a segmentation fault.*

  **Important**: It is *not* sufficient to set these variable within the Conda
  environment, like the commands above do for `LD_LIBRARY_PATH`. To avoid having
  to set them every time you launch a new shell, we recommend adding them to
  `~/.profile` (create the file if it does not exist), and to `~/.bash_profile` or
  `~/.bash_login` if such a file exists.

  [//]: # (End complete install)

  MPI uses [SSH](https://en.wikipedia.org/wiki/Secure_Shell) or
  [RSH](https://en.wikipedia.org/wiki/Remote_Shell) to communicate with each node
  unless another resource manager, such as
  [SLURM](https://slurm.schedmd.com/overview.html), is used. If you are
  encountering an error "The value of the MCA parameter `plm_rsh_agent` was set to
  a path that could not be found", please make sure you have an SSH Client
  installed.



  You should now be able to import CUDA-Q and start building quantum programs in
  Python!

  ```console
  import cudaq

  kernel = cudaq.make_kernel()
  qubit = kernel.qalloc()
  kernel.x(qubit)
  kernel.mz(qubit)

  result = cudaq.sample(kernel)
  ```

  Additional examples and documentation are linked in the [release
  notes][cudaq_docs_releases].



  There are many ways in which you can get involved with CUDA-Q. If you are
  interested in developing quantum applications with CUDA-Q, our [GitHub
  repository][github_link] is a great place to get started! For more information
  about contributing to the CUDA-Q platform, please take a look at
  [Contributing.md](https://github.com/NVIDIA/cuda-quantum/blob/main/Contributing.md).



  CUDA-Q is an open source project. The source code is available on
  [GitHub][github_link] and licensed under [Apache License
  2.0](https://github.com/NVIDIA/cuda-quantum/blob/main/LICENSE). CUDA-Q makes use
  of the NVIDIA cuQuantum SDK to enable high-performance simulation, which is held
  to its own respective license.

  [github_link]: https://github.com/NVIDIA/cuda-quantum/



  Please let us know your feedback and ideas for the CUDA-Q platform in the
  [Discussions][discussions] tab of our [GitHub repository][github_repo], or [file
  an issue][cuda_quantum_issues]. To report security concerns please reach out to
  [cuda-quantum@nvidia.com](mailto:cuda-quantum@nvidia.com).

  [discussions]: https://github.com/NVIDIA/cuda-quantum/discussions
  [cuda_quantum_issues]: https://github.com/NVIDIA/cuda-quantum/issues
  [github_repo]: https://github.com/NVIDIA/cuda-quantum

rpm_license:
  Apache License Version 2.0  Copyright (c) 2023 - 2024 NVIDIA Corporation & Affiliates All rights reserved.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 328d0813285a49270b1eb49a9225ac64f90dc5fbc06a435b2666438c8b7555a8
name: python-cuddly-octo-funicular
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/yu9824/cuddly-octo-funicular
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuddly-octo-funicular-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/CI.yml/badge.svg)](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/CI.yml)
  [![docs](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/docs.yml/badge.svg)](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/docs.yml)

  [![release-pypi](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/release-pypi.yml/badge.svg)](https://github.com/yu9824/cuddly-octo-funicular/actions/workflows/release-pypi.yml)

  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  <!--
  [![python_badge](https://img.shields.io/pypi/pyversions/cuddly-octo-funicular)](https://pypi.org/project/cuddly-octo-funicular/)
  [![license_badge](https://img.shields.io/pypi/l/cuddly-octo-funicular)](https://pypi.org/project/cuddly-octo-funicular/)
  [![PyPI version](https://badge.fury.io/py/cuddly-octo-funicular.svg)](https://pypi.org/project/cuddly-octo-funicular/)
  [![Downloads](https://static.pepy.tech/badge/cuddly-octo-funicular)](https://pepy.tech/project/cuddly-octo-funicular)

  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/cuddly-octo-funicular.svg)](https://anaconda.org/conda-forge/cuddly-octo-funicular)
  [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/cuddly-octo-funicular.svg)](https://anaconda.org/conda-forge/cuddly-octo-funicular)
  -->

  Before [pep518](https://peps.python.org/pep-0518/)
  - `setup.py`
  - `setup.cfg`
  - `ruff.toml`

  After [pep518](https://peps.python.org/pep-0518/)
  - `pyproject.toml`





  1. `release-pypi.yml` の `# FIXME: uncomment` の部分をアンコメントする。
  2. パッケージ名を変える ( `cuddly-octo-funicular` のところ)



  ```bash
  git remote add regro-cf-autotick-bot git@github.com:regro-cf-autotick-bot/cuddly-octo-funicular-feedstock.git
  git fetch regro-cf-autotick-bot

  ```

  - [Official Documents](https://conda-forge.org/docs/maintainer/updating_pkgs/)
  - [日本語でのブログ記事](https://zenn.dev/pejpo/articles/9f767fa1bf031e)

rpm_license:
  MIT License  Copyright (c) 2024 yu9824  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: dede262400c45d8bfdfbcdfc89160f4c2de15d589df202c1c9dfd8f8fe6c4993
name: python-cudo-compute
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A client for cudocompute.com
url: https://www.cudocompute.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cudo-compute-0.3.0-1.src.rpm
checksum_type: sha256
description:
  To use this client install cudoctl and run ``./cudoctl init`` follow the steps to enter your API key and choose your project.

  Then when you call cudo_api in python it will grab your API key from the yaml file created by cudoctl.

  ```bash
  pip install cudo-compute
  ```

  ```python
  from cudo_compute import cudo_api

  api = cudo_api.virtual_machines()
  vms = api.list_vms(cudo_api.project_id())
  ```

  More examples of various api calls can be found in ``examples``.




  The code is generated by swagger codegen cli.

  Most code is generated in github actions see .github/workflows the generated code is put into a /src/cudo_compute directory
  The code gets modified and the helpers get copied in from /helpers.

  ``./codegen.sh`` generates docs directory with source code and documentation.

  If you wish to customise how the API key or project is selected see the code in the helpers directory.


pkgId: 0247ce42647b2e948e8e41ba36bb23011d37735b9f7c0473883f5c35aeb7ae27
name: python-cuenca
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Cuenca API Client
url: https://github.com/cuenca-mx/cuenca-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuenca-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/cuenca-mx/cuenca-python/workflows/test/badge.svg)](https://github.com/cuenca-mx/cuenca-python/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/cuenca-mx/cuenca-python/branch/main/graph/badge.svg)](https://codecov.io/gh/cuenca-mx/cuenca-python)
  [![PyPI](https://img.shields.io/pypi/v/cuenca.svg)](https://pypi.org/project/cuenca/)



  `pip install cuenca`



  The preferred way to configure the credentials for the client is to set the
  `CUENCA_API_KEY` and `CUENCA_API_SECRET` environment variables. The client
  library will automatically configure based on the values of those variables.

  To configure manually:
  ```python
  import cuenca

  cuenca.configure(api_key='PKxxxx', api_secret='yyyyyy')
  ```



  JWT tokens can also be used if your credentials have enough permissions. To
  do so, you may include the parameter `use_jwt` as part of your `configure`

  ```python
  import cuenca

  cuenca.configure(use_jwt=True)
  ```

  A new token will be created at this moment and automatically renewed before
  sending any request if there is less than 5 minutes to be expired according
  to its payload data.






  ```python
  import cuenca

  cuenca.configure(sandbox=True)  # if using sandbox

  local_transfer_id = '078efdc20bab456285437309c4b75673'

  transfer = cuenca.Transfer.create(
      recipient_name='Benito Juárez',
      account_number='646180157042875763',  # CLABE or card number
      amount=12345,  # Mx$123.45
      descriptor='sending money',  # As it'll appear for the customer
      idempotency_key=local_transfer_id
  )


  transfer.refresh()
  ```




  ```python
  import cuenca

  transfer = cuenca.Transfer.retrieve('tr_123')
  ```



  Results are always returned in descending order of `created_at`

  The methods that can be used:
  - `one()` - returns a single result. Raises `NoResultFound` if there are no
  results and `MultipleResultsFound` if there are more than one
  - `first()` - returns the first result or `None` if there aren't any
  - `all()` - returns a generator of all matching results. Pagination is handled
  automatically as you iterate over the response
  - `count()` - returns an integer with the count of the matching results

  ```python
  import cuenca
  from cuenca.types import Status


  local_transfer_id = '078efdc20bab456285437309c4b75673'
  transfer = cuenca.Transfer.one(idempotency_key=local_transfer_id)


  transfers = cuenca.Transfer.all(
      account_number='646180157000000004',
      status=Status.succeeded
  )


  count = cuenca.Transfer.count(status=Status.succeeded)
  ```



  ```python
  import cuenca


  balance = cuenca.get_balance()

  ```





  ```python
  import cuenca


  new = cuenca.ApiKey.create()


  old_id = cuenca.session.auth[0]
  cuenca.session.configure(new.id, new.secret)
  cuenca.ApiKey.deactivate(old_id, 60)  # revoke prior API key in an hour
  ```




  Create a new password
  ```python
  cuenca.UserCredential.create(password='1234567890')
  ```

  To update your password
  ```python
  cuenca.UserCredential.update(password='1234567890')
  ```

  To reset password
  ```python
  cuenca.UserCredential.update(password=None)
  ```

  Login in and out
  ```python
  cuenca.UserLogin.create(password='1234567890')
  ...  # authenticated operation
  cuenca.UserLogin.logout()
  ```

  Create login token for biometrics
  ```python

  cuenca.UserLogin.create(password='1234567890')
  token = cuenca.LoginToken.create()
  cuenca.UserLogin.logout()


  cuenca.configure(login_token=token)
  ...  # authenticated operation
  ```


