# packages

pkgId: 02bf3af67a0d3862842ef9a3a8a0fa3fe5bd768aef530b0973e577e902261545
name: python-CPred
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://github.com/VilenneFrederique/CPred
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CPred-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  CPred: A deep learning framework for predicting the charge state distribution in modified and unmodified peptides in ESI

description:
  - [Introduction](#introduction)
  - [Installation](#installation)
  - [How to use](#How-to-use)
    - [Python module](#Python-module)
    - [Command line interface](#command-line-interface)
    - [Input files](#input-files)
    - [Prediction models](#prediction-models)
  - [Citation](#citation)

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 3fbd280f5302909503204a3c3e5843fc5fb348f33354e106bd5b8b8663b65081
name: python-CProfileV
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: An easier way to use cProfile
url: https://github.com/ymichael/cprofilev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CProfileV-1.0.7-1.src.rpm
checksum_type: sha256
description:
  An easier way to use cProfile.

  Outputs a simpler html view of profiled stats.
  Able to show stats while the code is still running!


pkgId: 06a53cee61732bfda3d471bc9da39901f614f8d62642291ed53a2c3d29e56c4b
name: python-CRIkit2
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Hyperspectral imaging (HSI) processing and analysis platform (user interface, UI)
url: https://github.com/CCampJr/CRIkit2
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CRIkit2-0.4.4-1.src.rpm
checksum_type: sha256
description:
  CRIKit2, formerly the Coherent Raman Imaging toolKit, is a hyperspectral
  imaging (HSI) platform. It is composed of command line tools, interactive tools,
  and a user interface.
  Github Repository: https://github.com/CCampJr/CRIkit2
  Docs Website: Coming Soon...
  **Note:** **Help Documentation** available via the Help header within the CRIkit2 GUI (only for git installs, **not pip**)
  HSI Processing:
  -   Dark subtraction
  -   Detrending
  -   Denoising via SVD
  Coherent Raman-Specific Processing:
  -   Kramers-Kronig phase retrieval
  -   Phase- and scale-error correction
  Coming Soon:
  -   SVD automated selection tools
  -   Analysis toolkit (separate UI)
  -   Interactive Raman database
  -   Much more


pkgId: 348120f5e93b716a1414f933da8c99b16ab5cf9e655fe0fce683c5ce985ed3be
name: python-CRYSTALClear
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Python framework for the CRYSTAL code.
url: https://github.com/crystaldevs/CRYSTALClear
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CRYSTALClear-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Python framework for the <a href="https://www.crystal.unito.it/index.php">CRYSTAL code</a>. Forked from <a href="https://github.com/crystal-code-tools/CRYSTALpytools">CRYSTALpytools</a>.


pkgId: 1abbe8470c77f3a3799252286d93c6261ba6641cde0b4f06376655c07d084d2e
name: python-CRYSTALpytools
arch: src
version: 2024.11.2
epoch: 0
release: 1
summary: Python tools for the CRYSTAL code developed and mantained by the CRYSTAL code developers.
url: https://github.com/crystal-code-tools/CRYSTALpytools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CRYSTALpytools-2024.11.2-1.src.rpm
checksum_type: sha256
description:
  Python tools for the <a href="https://www.crystal.unito.it/index.php">CRYSTAL code</a> developed and mantained by the CRYSTAL code developers


pkgId: b44581070b7c620a372882d568abcf853c29ceeed58a412c1133605238bd2048
name: python-CSET
arch: src
version: 24.8.0
epoch: 0
release: 1
summary: Toolkit for evaluation and investigation of numerical models for weather and climate applications.
url: https://pypi.org/project/CSET/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSET-24.8.0-1.src.rpm
checksum_type: sha256
description:
  CSET is a toolkit for evaluation, verification and investigation of convective-
  and turbulence-scale numerical models for weather and climate applications,
  cutting across time and space scales.

  It aligns parametrisation development, diagnostic development and evaluation
  research, feeding back into Regional Atmosphere and Land (RAL) model development
  across the Met Office and UM partnership.

  Apart from verification capabilities it provides a centralised source of tools
  to aid process-oriented evaluation for UM and LFRic models, supporting both
  deterministic and ensembles.

  For model developers CSET offers well documented and peer reviewed evaluation
  tools and flexible evaluation code that can adapt to users needs.

  For diagnostic developers it provides a legacy for diagnostics and observations.
  It is build on a modern software stack using python 3 and METplus. Clear
  documentation, working practices, automatic testing, and open access promote
  contributions.

  Please read [the documentation](https://metoffice.github.io/CSET) to learn more
  about CSET, and how to use it.

  If you want to ask or share with the CSET community, please use the relevant
  category of the [Simulation Systems Discussions
  Forum](https://github.com/MetOffice/simulation-systems/discussions/categories/cset-toolkit).



  Contributions are readily welcomed! To get started with developing CSET visit
  the [Contributing](https://metoffice.github.io/CSET/contributing/) section of
  the documentation.

  In addition to reading the working practices, the key
  recommendation is early communication. Open an [issue on
  Github](https://github.com/MetOffice/CSET/issues) with your proposed change or
  addition in the design phase, and then others can provide guidance early.



  © Crown copyright, Met Office (2022-2024) and CSET contributors.

  Licensed under the [Apache License, Version 2.0](LICENCE) (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.

  GitHub Copilot was used in the development of this software.


pkgId: c1f1e609ce12f6e9f0c82db99eee9c206ec84f4bb7f9c03292235e11ae08db6e
name: python-CSF-3DFin
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: CSF: Ground Filtering based on Cloth Simulation
url: http://ramm.bnu.edu.cn/projects/CSF/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSF-3DFin-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ![csf1](https://github.com/jianboqi/CSF/blob/master/CSFDemo/CSF1.png) ![csf2](https://github.com/jianboqi/CSF/blob/master/CSFDemo/CSF2.png)

  Airborne LiDAR filtering method based on Cloth Simulation.
  This is the code for the article:

  W. Zhang, J. Qi*, P. Wan, H. Wang, D. Xie, X. Wang, and G. Yan, “An Easy-to-Use Airborne LiDAR Data Filtering Method Based on Cloth Simulation,” Remote Sens., vol. 8, no. 6, p. 501, 2016.
  (http://www.mdpi.com/2072-4292/8/6/501/htm)


  **This is a modified version of the original Code for 3DFin purposes**

  For now this is only intended to be used inside [3DFin](https://github.com/3DFin/3Dfin)/[dendromatics](https://github.com/3DFin/dendromatics).
  But this repository also serve as a playground to bootstrap a planned full rewrite of CSF.

  List of changes:

  - Better handling of numpy arrays in the python bindings (avoid expensive copies)
  - Bug fixes and improvement (mostly backport from CloudCompare version of CSF and original ones)
  - Better (but yet to be improved) documentation and code structure.

  **New feature has been implemented:**

  Now, We has wrapped a Python interface for CSF with swig. It is simpler to use now. This new feature can make CSF easier to be embeded into a large project. For example, it can work with Laspy (https://github.com/laspy/laspy). What you do is just read a point cloud into a python 2D list, and pass it to CSF.
  The following example shows how to use it with laspy.
  ```python

  import laspy
  import CSF
  import numpy as np

  inFile = laspy.read(r"in.las") # read a las file
  points = inFile.points
  xyz = np.vstack((inFile.x, inFile.y, inFile.z)).transpose() # extract x, y, z and put into a list

  csf = CSF.CSF()


  csf.params.bSloopSmooth = False
  csf.params.cloth_resolution = 0.5


  csf.setPointCloud(xyz)
  ground = CSF.VecInt()  # a list to indicate the index of ground points after calculation
  non_ground = CSF.VecInt() # a list to indicate the index of non-ground points after calculation
  csf.do_filtering(ground, non_ground) # do actual filtering.

  outFile = laspy.LasData(inFile.header)
  outFile.points = points[np.array(ground)] # extract ground points, and save it to a las file.
  out_file.write(r"out.las")
  ```

  **Reading data from txt file:**

  If the lidar data is stored in txt file (x y z for each line), it can also be imported directly.

  ```python
  import CSF

  csf = CSF.CSF()
  csf.readPointsFromFile('samp52.txt')

  csf.params.bSloopSmooth = False
  csf.params.cloth_resolution = 0.5

  ground = CSF.VecInt()  # a list to indicate the index of ground points after calculation
  non_ground = CSF.VecInt() # a list to indicate the index of non-ground points after calculation
  csf.do_filtering(ground, non_ground) # do actual filtering.
  csf.savePoints(ground,"ground.txt")
  ```


  Thanks to [@rjanvier](https://github.com/rjanvier)'s contribution. Now we can install CSF from pip as:
  ```python
  pip install cloth-simulation-filter
  ```


  see more details from file `demo_mex.m` under matlab folder.



  Thanks to the nice work of @Jean-Romain, through the collaboration, the CSF has been made as a R package, the details can be found in the [RCSF repository](https://github.com/Jean-Romain/RCSF). This package can be used easily with the [lidR package](https://github.com/Jean-Romain/lidR):

  ```r
  library(lidR)
  las  <- readLAS("file.las")
  las  <- lasground(las, csf())
  ```


  Now, CSF is built by CMake, it produces a static library, which can be used by other c++ programs.

  To build the library, run:
  ```bash
  mkdir build #or other name
  cd build
  cmake ..
  make
  sudo make install
  ```
  or if you want to build the library and the demo executable `csfdemo`

  ```bash
  mkdir build #or other name
  cd build
  cmake -DBUILD_DEMO=ON ..
  make
  sudo make install

  ```


  You can use CMake GUI to generate visual studio solution file.


  For binary release version, it can be downloaded at: http://ramm.bnu.edu.cn/projects/CSF/download/

  Note: This code has been changed a lot since the publication of the corresponding paper. A lot of optimizations have been made. We are still working on it, and wish it could be better.


  At last, if you are interested in Cloudcompare, there is a good news. our method has been implemented as a Cloudcompare plugin, you can refer to : https://github.com/cloudcompare/trunk


  A tool named `CSFTools` has been recently released, it is based on CSF, and provides dem/chm generation, normalization. Please refer to: https://github.com/jianboqi/CSFTools


  CSF is maintained and developed by Jianbo QI. It is now released under Apache 2.0.


pkgId: a6b27ab199dbc88263f1aa0b8dc2c5a84879c932d9da94e6ffcf655a650f65a7
name: python-CSGVulcan
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A tiny library for describing data as a resource
url: https://pypi.org/project/CSGVulcan/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSGVulcan-0.3.2-1.src.rpm
checksum_type: sha256
description:
  > A tiny python library for expressing data as a resource.



  A quick introduction of the minimal setup you need to get a hello world up &
  running.

  ```shell
  pip install CSGVulcan
  ```

  ```python
  from CSGVulcan import VulcanResource, VulcanAPI

  class MyNewResource(VulcanResource):
      def __init__(self, resource, name=__file__):
          self.super().__init__(resource, name=name)

      def init(self, _context):
          return "Init"

      def  fetch_one(self, _context):
          return "Fetch One"

      def fetch_all(self, _context):
          return "Fetch All"

  my_new_resource = MyNewResource()
  my_new_resource_api = VulcanAPI(resource=my_new_resource)

  my_new_resource_api.run(port=8080, debug=True)
  ```

  CSGVulcan will then spin up a Flask Web Server at 127.0.0.1:8080
  with the following routes available for consumption.

  - /api/ping
  - /api/fetch-one
  - /api/fetch-all





  If you're interested in developing and contributing to Vulcan, first, clone this project
  from Github. Secondly, set up your local environemnt for develpment. It is recommended to
  create a python virtual environment to manage your dependencies, here is how to do
  that.

  Create and activate your virtualenv.

  ```shell
  python -m venv venv
  ```

  ```shell
  source ./venv/bin/activate
  ```

  Pip install the depdencies

  ```shell
  pip install -r requirements.txt
  ```



  - Provides a simple and consistent interface for describing data from external resources.
  - Once defined, your VulcanResource is then easily converted into a REST API.



  If you'd like to contribute, please fork the repository and use a feature
  branch. Pull requests are warmly welcomed.

  Vulcan is a tool designed to serve others, so any and all feedback is expected and
  encouraged. We aim to create a better pattern for accessing data, if you have ideas, contribute them.



  Vulcan is written using autopep8 and pylint, it is recommended to leverage those to allow
  for consistent styling of source code.



  Though not exhaustive, here is a list of useful links that may help in developing an understanding of Vulcan and what it is comprised of.

  - [Flask](http://flask.pocoo.org/)


pkgId: 9cf219e51057ae6b4e96c5d12741d5910c089d0ce23d991f79ef7916f48e1894
name: python-CSSLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CSSLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CSSLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSSLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Check code for syntactical or semantical problems that might lead to
      problems or inefficiencies.


pkgId: dd495b886b4aab16d43d0260e50335771436e6640c56fa3c4d2b8d9e35768f67
name: python-CSSOnDiet
arch: src
version: 1.8.4
epoch: 0
release: 1
summary: A preprocessor for designers
url: http://cssondiet.com
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSSOnDiet-1.8.4-1.src.rpm
checksum_type: sha256
description:
  CSS-On-Diet is a preprocessor for CSS files. The key feature is
  mnemonics for frequently used properties, which are similar to Emmet
  abbreviations. Other goodies include intuitive media breakpoints, nested
  and single line comments, variables and mixins, a calculator,
  hexadecimal RGBA, minifier, ...
  Much more information on `cssondiet.com <http://cssondiet.com>`__


pkgId: 8133c97b258025c8f31e7a0758664034319ea1e514e54f2aa44fcad09a7e19a1
name: python-CSVtoTableNameless
arch: src
version: 2.3.0.3
epoch: 0
release: 1
summary: Simple commandline utility to convert CSV files to searchable and sortable HTML table.
url: https://github.com/NanashiTheNameless/csvtotable
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSVtoTableNameless-2.3.0.3-1.src.rpm
checksum_type: sha256
description:
  Simple command-line utility to convert CSV files to searchable and
  sortable HTML table. Supports large datasets and horizontal scrolling
  for large number of columns.

  DISCLAIMER: This is NOT an official version, nor am I affiliated
  with the original creator Vivek R \@vividvilla
  <https://github.com/vividvilla> (Upstream Author) This version is mostly
  for me, if you wanna use it too go ahead but I give no promises of
  function. If you notice any errors or issues please tell me!



  [Here is a demo](<https://NanashiTheNameless.github.io/csvtotable/sample/goog.html>)
  of [sample csv](<https://github.com/NanashiTheNameless/csvtotable/blob/master/sample/goog.csv>)
  file converted to HTML table.





  Get the Latest

  ```sh
  python -m pip install --upgrade 'CSVtoTableNameless @ git+https://github.com/NanashiTheNameless/csvtotable@master'
  ```

  Or get from PyPi (not recommended, may be out of date)

  ```sh
  pip install --upgrade CSVtoTableNameless
  ```



  ```sh
  csvtotable --help
  ```

  Convert `data.csv` file to `data.html` file

  ```sh
  csvtotable data.csv data.html
  ```

  Open output file in a web browser instead of writing to a file

  ```sh
  csvtotable data.csv --serve
  ```



  ```text
      Usage: csvtotable [OPTIONS] INPUT_FILE [OUTPUT_FILE]

        -c, -t, --caption, --title TEXT
                                        Table caption and HTML title
        -d, --delimiter TEXT            CSV delimiter
        -q, --quotechar TEXT            String used to quote fields containing
                                        special characters
        -dl, --display-length INTEGER   Number of rows to show by default. Defaults
                                        to -1 (show all rows)
        -o, --overwrite                 Overwrite the output file if exists.
        -s, --serve                     Open output html in browser instead of
                                        writing to file.
        -h, --height TEXT               Table height in px or in %.
        -p, --pagination                Enable/disable table pagination.
        -vs, --virtual-scroll INTEGER   Number of rows after which virtual scroll is
                                        enabled.Set it to -1 to disable and 0 to
                                        always enable.
        -nh, --no-header                Disable displaying first row as headers.
        -e, --export                    Enable filtered rows export options.
        -eo, --export-options [copy|csv|json|print]
                                        Enable specific export options. By default
                                        shows all. For multiple options use -eo flag
                                        multiple times. For ex. -eo json -eo csv
        -ps, --preserve-sort            Preserve the default sorting order (not
                                        using this flag will cause table to be
                                        sorted by first column).
        --help                          Show this message and exit.
  ```



  [All Major Contributors](https://github.com/NanashiTheNameless/csvtotable/blob/master/CONTRIBUTORS.md)

  [All Other Contributors](https://github.com/NanashiTheNameless/csvtotable/graphs/contributors)

  [Datatables](https://datatables.net)


pkgId: 5028626fc06dabf1726d57b1f811c8928b00d546ee23278810db7a08c1edecd1
name: python-CSVtoTableNameless
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Simple commandline utility to convert CSV files to searchable and sortable HTML table.
url: https://github.com/NanashiTheNameless/csvtotable
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSVtoTableNameless-2.4.1-1.src.rpm
checksum_type: sha256
description:
  Simple command-line utility to convert CSV files to searchable and
  sortable HTML table. Supports large datasets and horizontal scrolling
  for large number of columns.

  DISCLAIMER: This is NOT an official version, nor am I affiliated
  with the original creator Vivek R \@vividvilla
  <https://github.com/vividvilla> (Upstream Author) This version is mostly
  for me, if you wanna use it too go ahead but I give no promises of
  function. If you notice any errors or issues please tell me!



  [Here is a demo](<https://NanashiTheNameless.github.io/csvtotable/sample/goog.html>)
  of [sample csv](<https://github.com/NanashiTheNameless/csvtotable/blob/master/sample/goog.csv>)
  file converted to HTML table.





  Get the Latest

  ```sh
  python -m pip install --upgrade 'CSVtoTableNameless @ git+https://github.com/NanashiTheNameless/csvtotable@master'
  ```

  Or get from PyPi (not recommended, may be out of date)

  ```sh
  pip install --upgrade CSVtoTableNameless
  ```



  ```sh
  csvtotable --help
  ```

  Convert `data.csv` file to `data.html` file

  ```sh
  csvtotable data.csv data.html
  ```

  Open output file in a web browser instead of writing to a file

  ```sh
  csvtotable data.csv --serve
  ```



  ```text
      Usage: csvtotable [OPTIONS] INPUT_FILE [OUTPUT_FILE]

        -c, -t, --caption, --title TEXT
                                        Table caption and HTML title
        -d, --delimiter TEXT            CSV delimiter
        -q, --quotechar TEXT            String used to quote fields containing
                                        special characters
        -dl, --display-length INTEGER   Number of rows to show by default. Defaults
                                        to -1 (show all rows)
        -o, --overwrite                 Overwrite the output file if exists.
        -s, --serve                     Open output html in browser instead of
                                        writing to file.
        -h, --height TEXT               Table height in px or in %.
        -p, --pagination                Enable/disable table pagination.
        -vs, --virtual-scroll INTEGER   Number of rows after which virtual scroll is
                                        enabled.Set it to -1 to disable and 0 to
                                        always enable.
        -nh, --no-header                Disable displaying first row as headers.
        -e, --export                    Enable filtered rows export options.
        -eo, --export-options [copy|csv|json|print]
                                        Enable specific export options. By default
                                        shows all. For multiple options use -eo flag
                                        multiple times. For ex. -eo json -eo csv
        -ps, --preserve-sort            Preserve the default sorting order (not
                                        using this flag will cause table to be
                                        sorted by first column).
        --help                          Show this message and exit.
  ```



  [All Major Contributors](https://github.com/NanashiTheNameless/csvtotable/blob/master/CONTRIBUTORS.md)

  [All Other Contributors](https://github.com/NanashiTheNameless/csvtotable/graphs/contributors)



  [Datatables](https://datatables.net)

  [jQuery](https://jquery.com/)

  [JSZip](https://stuk.github.io/jszip/)

  [PDFMake](https://github.com/bpampuch/pdfmake)


pkgId: ef61dc10dcf054ecea2a8fe0653adf8e9cfb4da1a4b6846e3e93d6944ac524ba
name: python-CSecurityBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CSecurityBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CSecurityBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSecurityBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Report possible security weaknesses for C/C++.

      For more information, consult <http://www.dwheeler.com/flawfinder/>.


pkgId: 4d7133f70c67e550c341b7960295395a327453744187c37e816cc28c08833201
name: python-CSolver.py
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Official API wrapper for https://csolver.xyz
url: https://github.com/AG-597/CSolver
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CSolver.py-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Simple Captcha Solving Service



  Hcaptcha & Recaptcha are solvable using CSolver



  https://csolver.xyz for more information


pkgId: 49eff55a3fafe3cbb883ae968ad97b57cbc1b1b8598d3b52093ed03ddbc603c2
name: python-CT3
arch: src
version: 3.3.3.post1
epoch: 0
release: 1
summary: Cheetah is a template engine and code generation tool
url: https://cheetahtemplate.org/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CT3-3.3.3.post1-1.src.rpm
checksum_type: sha256
description:
  For a high-level introduction to Cheetah please refer to the User's Guide
  at https://cheetahtemplate.org/users_guide/index.html


pkgId: dc6dbd88a01f3c8e3d0daaa6a435e4452b0ceaeb6a793945ae06a8e553c5b65b
name: python-CTADIRAC
arch: src
version: 2.2.54
epoch: 0
release: 1
summary: CTADIRAC is an extension of the DIRAC interware for dedicated CTA usage.
url: https://gitlab.cta-observatory.org/cta-computing/dpps/CTADIRAC/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTADIRAC-2.2.54-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://badge.fury.io/py/CTADIRAC.svg)](https://pypi.org/project/CTADIRAC/)



  * CTADIRAC is a customized version of the DIRAC interware. As of today, it allows an easy and optimized access to Grid resources (mainly EGI) available to the CTA Virtual Organization (vo.cta.in2p3.fr). When CTAO DPPS will be setup, CTADIRAC will serve as the Computing Ressource and Worflow Management System.
  * Follow the [CTADIRAC specific documentation](https://redmine.cta-observatory.org/projects/cta_dirac/wiki/CTA-DIRAC_Users_Guide)
  * [Wiki](https://gitlab.cta-observatory.org/cta-computing/dpps/CTADIRAC/-/wikis/)




  See the dedicated [client installation documentation](docs/install_client.md).



  See the dedicated [server installation documentation](docs/install_CTADIRAC.md).


  [CTADIRAC Helm charts](https://gitlab.cta-observatory.org/cta-computing/dpps/workload/CTADIRAC-charts) (in development).

  [CTADIRAC fleet deployment](https://gitlab.cta-observatory.org/cta-computing/dpps/workload/ctadirac-deployment) on a Kubernetes cluster.



  * Get `CTADIRAC` on `PyPi`:

  ```
  pip install CTADIRAC
  ```

  * Get `CTADIRAC` client `docker` image:

  ```
  docker pull gitlab.cta-observatory.org:5555/cta-computing/dpps/ctadirac/dirac-client:latest
  ```



  To contribute to CTADIRAC, please check out the full [DIRAC developers guide](http://dirac.readthedocs.io/en/integration/DeveloperGuide/index.html).



  ```bash

  git clone git@gitlab.cta-observatory.org:cta-computing/dpps/workload/CTADIRAC.git
  cd CTADIRAC


  mamba env create --file environment.yml
  mamba activate ctadirac-dev


  pip install -e .


  mamba install pre-commit
  pre-commit install
  ```



  ```bash

  mamba env create -y --file utils/ci/env/coverage.yml
  mamba activate coverage


  python -m pip install -e .


  python -m pytest tests/unit

  python -m pytest tests/unit --cov=src/CTADIRAC/ --cov-report=term
  ```


  * Luisa Arrabito <arrabito@in2p3.fr>


pkgId: 5df7a82500cf311213807d21e6b31bb806b304d109594b34b48e1b7926ec0c02
name: python-CTADIRAC
arch: src
version: 2.2.58
epoch: 0
release: 1
summary: CTADIRAC is an extension of the DIRAC interware for dedicated CTA usage.
url: https://gitlab.cta-observatory.org/cta-computing/dpps/CTADIRAC/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTADIRAC-2.2.58-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://badge.fury.io/py/CTADIRAC.svg)](https://pypi.org/project/CTADIRAC/)
  [![SQ - Quality Gate](https://sonar-cta-dpps.zeuthen.desy.de/api/project_badges/measure?project=cta-computing_dpps_CTADIRAC_AYcypMiTBJOBl6qHRhPT&metric=alert_status&token=sqb_f393351b89087355ed88f19a2a20955620293e2b)](https://sonar-cta-dpps.zeuthen.desy.de/dashboard?id=cta-computing_dpps_CTADIRAC_AYcypMiTBJOBl6qHRhPT)
  [![SQ - Coverage](https://sonar-cta-dpps.zeuthen.desy.de/api/project_badges/measure?project=cta-computing_dpps_CTADIRAC_AYcypMiTBJOBl6qHRhPT&metric=coverage&token=sqb_f393351b89087355ed88f19a2a20955620293e2b)](https://sonar-cta-dpps.zeuthen.desy.de/dashboard?id=cta-computing_dpps_CTADIRAC_AYcypMiTBJOBl6qHRhPT)



  * CTADIRAC is a customized version of the DIRAC interware. As of today, it allows an easy and optimized access to Grid resources (mainly EGI) available to the CTA Virtual Organization (vo.cta.in2p3.fr). When CTAO DPPS will be setup, CTADIRAC will serve as the Computing Ressource and Worflow Management System.
  * Follow the [CTADIRAC specific documentation](https://redmine.cta-observatory.org/projects/cta_dirac/wiki/CTA-DIRAC_Users_Guide)
  * [Wiki](https://gitlab.cta-observatory.org/cta-computing/dpps/CTADIRAC/-/wikis/)




  See the dedicated [client installation documentation](docs/install_client.md).



  See the dedicated [server installation documentation](docs/install_CTADIRAC.md).


  [CTADIRAC Helm charts](https://gitlab.cta-observatory.org/cta-computing/dpps/workload/CTADIRAC-charts) (in development).

  [CTADIRAC fleet deployment](https://gitlab.cta-observatory.org/cta-computing/dpps/workload/ctadirac-deployment) on a Kubernetes cluster.



  * Get `CTADIRAC` on `PyPi`:

  ```
  pip install CTADIRAC
  ```

  * Get `CTADIRAC` client `docker` image:

  ```
  docker pull gitlab.cta-observatory.org:5555/cta-computing/dpps/ctadirac/dirac-client:latest
  ```



  To contribute to CTADIRAC, please check out the full [DIRAC developers guide](http://dirac.readthedocs.io/en/integration/DeveloperGuide/index.html).



  ```bash

  git clone git@gitlab.cta-observatory.org:cta-computing/dpps/workload/CTADIRAC.git
  cd CTADIRAC


  mamba env create --file environment.yml
  mamba activate ctadirac-dev


  pip install -e .


  mamba install pre-commit
  pre-commit install
  ```



  ```bash

  mamba env create -y --file utils/ci/env/coverage.yml
  mamba activate coverage


  python -m pip install -e .


  python -m pytest tests/unit

  python -m pytest tests/unit --cov=src/CTADIRAC/ --cov-report=term
  ```


  * Luisa Arrabito <arrabito@in2p3.fr>


pkgId: 796feff095aef792006e16a38ab99939813bf2ea5d7de5f3a4fd3669d1aa39f4
name: python-CTApy
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Python package for the Conditional Topic Allocation (CTA)
url: https://github.com/twekhof/CTA
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTApy-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Python package for the "Conditional Topic Allocation" (CTA): a text-analysis method that identifies topics that correlate with numerical outcomes.


  * Corresponding research paper: [Conditional Topic Allocations for Open-Ended Survey Responses (2024)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4190308).





  CTA finds topics by conditioning on observables. For example, do Republicans write differently about politics than Democrats?
  It consists of three steps:

  <br>
  1. Predict the outcome variable with text.

  * Uses DistilBERT to predict outcome.

   <br>
  2. Select words with high predictive power (positive or negative).

  * Calculates SHAP values for each word and select words with a statistically significant SHAP value.

  <br>
  3. Group words by semantic similarity.

  * Returns topics with either positive or negative correlation with the outcome.

  <br>
  CTA supports all languages.



  CTApy requires Python 3.9 and pip.
  It is highly recommended to use a virtual environment (or conda environment) for the installation.

  ```bash

  python -m pip install -U pip wheel setuptools


  python -m pip install -U CTApy
  ```

  If you want to use Jupyter, make sure you have it installed in the current environment.



  Please see the hands-on tutorials, which replicate the research paper: [https://github.com/twekhof/CTA/tree/main/tutorials](https://github.com/twekhof/CTA/tree/main/tutorials).




  `CTApy` was developed by

  [Tobias Wekhof](https://tobiaswekhof.com), ETH Zurich




  This Python package is a research tool currently under development. The authors take no responsibility for the accuracy or reliability of the results produced by it.


pkgId: 48e5057da1fe8a0fc9d66efd04d98f849064a01f6d38bdcfe6cc6ddd5467a4cf
name: python-CTRegisterMicroserviceFlask
arch: src
version: 0.5.1
epoch: 0
release: 1
url: https://pypi.org/project/CTRegisterMicroserviceFlask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTRegisterMicroserviceFlask-0.5.1-1.src.rpm
checksum_type: sha256
summary:
  Library to interact with the Control-Tower api-gateway (register, do requests to other microservices, etc)


pkgId: 4e38b79c1614ab62fefc151f41bc1ec6146c03370707e3ac06f10926f64ea09c
name: python-CTid-programmer
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A graphical user interface for programming CTid sensors.
url: https://bitbucket.org/egauge/CTid-programmer/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTid-programmer-1.5.0-1.src.rpm
checksum_type: sha256
description:
  ***************
  CTid-programmer
  ***************

  A graphical-user interface for programming CTid®-enabled sensors.

  The avrdude enhancements which enable programming of ATtiny
  microcontrollers with a standard FTDI serial cable have been merged
  into the official release.  If you have avrdude v7 or newer installed,
  you should be all set.


pkgId: dd76ea980df963860d6a05e8357dcecad0fed52386442c0dbad8bdca8561da62
name: python-CTkColorPicker
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A modern color picker for customtkinter
url: https://github.com/Akascape/CTkColorPicker
rpm_license: Creative Commons Zero v1.0 Universal
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTkColorPicker-0.9.0-1.src.rpm
checksum_type: sha256
description:
  **A modern color picker made for customtkinter!**

  ![Screenshot](https://user-images.githubusercontent.com/89206401/209182773-d76bf05c-610e-4297-aec5-7bb61a11d6d3.jpg)



  ```
  pip install CTkColorPicker
  ```




  - [customtkinter](https://github.com/TomSchimansky/CustomTkinter)
  - [pillow](https://pypi.org/project/Pillow/)


  ```python
  import customtkinter as ctk
  from CTkColorPicker import *

  def ask_color():
      pick_color = AskColor() # open the color picker
      color = pick_color.get() # get the color string
      button.configure(fg_color=color)

  root = ctk.CTk()

  button = ctk.CTkButton(master=root, text="CHOOSE COLOR", text_color="black", command=ask_color)
  button.pack(padx=30, pady=20)
  root.mainloop()
  ```


  | Arguments | Description |
  |---------|-------------|
  | width | set the overall size of the color picker window |
  | title | change the title of color picker window |
  | fg_color | change forground color of the color picker frame |
  | bg_color | change background color of the color picker frame |
  | button_color | change the color of the button and slider |
  | button_hover_color | change the hover color of the buttons |
  | text | change the default text of the 'OK' button |
  | initial_color | set the default color of color picker (currently in beta stage) |
  | slider_border | change the border width of slider |
  | corner_radius | change the corner radius of all the widgets inside color picker |
  | _**other button parameters_ | pass other button arguments if required |


  **This is a new color picker widget that can be placed inside a customtkinter frame.**

  ![Screenshot 2023-05-17 191125](https://github.com/Akascape/CTkColorPicker/assets/89206401/ca03751a-90a3-45e6-8ba4-745a92ab1c12)


  ```python
  from CTkColorPicker import *
  import customtkinter

  root = customtkinter.CTk()
  colorpicker = CTkColorPicker(root, width=500, command=lambda e: print(e))
  colorpicker.pack(padx=10, pady=10)
  root.mainloop()
  ```


  | Arguments | Description |
  |---------|-------------|
  | master | parent widget |
  | width | set the overall size of the color picker frame |
  | fg_color | change forground color of the color picker frame |
  | initial_color | set the default color of color picker (currently in beta stage) |
  | slider_border | change the border width of slider |
  | corner_radius | change the corner radius of all the widgets inside color picker |
  | command | add a command when the color is changed |
  | orientation | change orientation of slider and label |
  | _**other slider parameters_ | pass other slider arguments if required |

  **That's all, hope it will help!**


pkgId: e7e40929856b2efb04ca49708769c333e66e643d0e04ae0c9bddac3354a3bc54
name: python-CTkListbox
arch: src
version: 1.4
epoch: 0
release: 1
summary: Customtkinter Listbox widget
url: https://github.com/Akascape/CTkListbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTkListbox-1.4-1.src.rpm
checksum_type: sha256
description:
  This is a **listbox widget** for customtkinter, works just like the tkinter listbox.

  ![Screenshot](https://github.com/Akascape/CTkListbox/assets/89206401/256c135f-3d6c-4daa-87a5-b4572a2c905f)


  ```
  pip install CTkListbox
  ```



  ```python
  import customtkinter
  from CTkListbox import *

  def show_value(selected_option):
      print(selected_option)

  root = customtkinter.CTk()

  listbox = CTkListbox(root, command=show_value)
  listbox.pack(fill="both", expand=True, padx=10, pady=10)

  listbox.insert(0, "Option 0")
  listbox.insert(1, "Option 1")
  listbox.insert(2, "Option 2")
  listbox.insert(3, "Option 3")
  listbox.insert(4, "Option 4")
  listbox.insert(5, "Option 5")
  listbox.insert(6, "Option 6")
  listbox.insert(7, "Option 7")
  listbox.insert("END", "Option 8")

  root.mainloop()
  ```

  | Parameter | Description |
  |-----------| ------------|
  | **master** | parent widget  |
  | width | **optional**, set width of the listbox |
  | height | **optional**, set height of the listbox |
  | fg_color | foreground color of the listbox |
  | border_color | border color of the listbox frame |
  | border_width | width of the border frame |
  | text_color | set the color of the option text |
  | hover_color | set hover color of the options |
  | button_color | set color of unselected buttons |
  | highlight_color | set the selected color of the option |
  | font | set font of the option text |
  | command | calls a command when a option is selected |
  | multiple_selection | select multiple options in the listbox, `default=False`|
  | listvariable | use a tkinter variable to change the listbox content |
  | *other_parameters | _all other parameters of ctk_scrollable frame can be passed_ |


  - **.insert(index, option)**
     add new option to the listbox
  - **.get()**
     get the selected option(s)
  - **.delete(index)**
     delete any option from the listbox. `.delete("all")` deletes all options
  - **.size()**
     get the size of the listbox
  - **.activate(index)**
    activate any option
  - **.deactivate(index)**
    deactivate any option
  - **.curselection()**
    returns indexes of selected options
  - **.configure()**
     change some parameters for the listbox.
  - **.move_up(index)/.move_down(index)**
     Reorder options in the listbox


pkgId: 872bc3263a488757c65adfcd019eb923f086e80404a7beb3482faf989482ff34
name: python-CTkMessagebox
arch: src
version: 2.7
epoch: 0
release: 1
summary: A modern messagebox for customtkinter
url: https://github.com/Akascape/CTkMessagebox
rpm_license: Creative Commons Zero v1.0 Universal
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTkMessagebox-2.7-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">CTkMessagebox</h1>

  <h3 align="center">A modern and fully customizable messagebox for CustomTkinter, A must-have extension pack!</h3>

  <div align="center">

    <a href="https://creativecommons.org/publicdomain/zero/1.0/">![License](https://img.shields.io/badge/License-CC0_1.0-blue)</a>
    <a href="https://github.com/Akascape/CTkMessagebox/archive/refs/heads/main.zip">![Download](https://img.shields.io/badge/Source_Code-Download-blue)</a>
    [![PyPI](https://img.shields.io/pypi/v/CTkMessagebox?style=flat)](https://pypi.org/project/CTkMessagebox)
    [![Downloads](https://static.pepy.tech/badge/ctkmessagebox)](https://pepy.tech/project/ctkmessagebox)
    ![Platform](https://img.shields.io/powershellgallery/p/Pester?color=blue)
  </div>


  <div align="center">

  ![3d](https://github.com/Akascape/CTkMessagebox/assets/89206401/cce577fc-6426-4c09-96f9-ede88caf7784)

  </div>

  <br>

  <h2 align="center"> Features </h2>

  - Customize all elements inside the messagebox
  - Add custom icons or images
  - Add multiple options according to your wish
  - No ugly looking header or borders
  - Comes with **5 default icons**
  - Spawns at center of the screen/app
  - Draggable window
  - Fade-in/Fade-out window effect

  <br>

  <h2 align="center"> Installation </h2>

  <div align="center">

  ```
  pip install CTkMessagebox
  ```

  [<img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/Akascape/CTkMessagebox?&color=green&label=Source%20Code&logo=Python&logoColor=yellow&style=for-the-badge"  width="300">](https://github.com/Akascape/CTkMessagebox/archive/refs/heads/main.zip)


  </div>

  <br>

  <h2 align="center"> How it looks? </h2>

  <div align="center">

  ![Screenshot](https://user-images.githubusercontent.com/89206401/221258593-75058878-b598-40c3-828a-1d44a6cefb73.jpg)

  </div>

  <br>

  <h2 align="center"> Example </h2>

  ```python
  from CTkMessagebox import CTkMessagebox
  import customtkinter

  def show_info():
      
      CTkMessagebox(title="Info", message="This is a CTkMessagebox!")

  def show_checkmark():
      
      CTkMessagebox(message="CTkMessagebox is successfully installed.",
                    icon="check", option_1="Thanks")

  def show_error():
      
      CTkMessagebox(title="Error", message="Something went wrong!!!", icon="cancel")

  def show_warning():
      
      msg = CTkMessagebox(title="Warning Message!", message="Unable to connect!",
                    icon="warning", option_1="Cancel", option_2="Retry")

      if msg.get()=="Retry":
          show_warning()

  def ask_question():
      
      msg = CTkMessagebox(title="Exit?", message="Do you want to close the program?",
                          icon="question", option_1="Cancel", option_2="No", option_3="Yes")
      response = msg.get()

      if response=="Yes":
          app.destroy()
      else:
          print("Click 'Yes' to exit!")

  app = customtkinter.CTk()
  app.rowconfigure((0,1,2,3,4,5), weight=1)
  app.columnconfigure(0, weight=1)
  app.minsize(200,250)

  customtkinter.CTkLabel(app, text="CTk Messagebox Examples").grid(padx=20)
  customtkinter.CTkButton(app, text="Check CTkMessagebox", command=show_checkmark).grid(padx=20, pady=10, sticky="news")
  customtkinter.CTkButton(app, text="Show Info", command=show_info).grid(padx=20, pady=10, sticky="news")
  customtkinter.CTkButton(app, text="Show Error", command=show_error).grid(padx=20, pady=10, sticky="news")
  customtkinter.CTkButton(app, text="Show Warning", command=show_warning).grid(padx=20, pady=10, sticky="news")
  customtkinter.CTkButton(app, text="Ask Question", command=ask_question).grid(padx=20, pady=(10,20), sticky="news")

  app.mainloop()

  ```

  <br>

  <h2 align="center"> OPTIONS </h2>

  <div align="center">

    | Parameters  | Description |
    | -------- | ----------- |
    | _master_ | set parent window (optional), the box will spawn at center of the parent window |
    | _width_ | width of the window in px (optional) |
    | _height_ | height of the window in px (optional) |
    | _fg_color_ | forground color of the messagebox [middle portion] |
    | _bg_color_  | background color of the messagebox |
    | **_title_** | title of the messagebox |
    | **_message_** | main message of the messagebox which will be shown at the center |
    | **_option_1_** | the text on the first button [Default is 'OK'] |
    | **_option_2_** | the text on the second button |
    | **_option_3_** | the text on the last button |
    | _options_ | directly pass a list containing the options in order |
    | _button_color_ | color of the buttons |
    | _text_color_ | color of the message-text |
    | _title_color_ | color of the title-text |
    | _button_text_color_ | color of the button-text |
    | _button_hover_color_ | hover color of the buttons |
    | _button_width_ | width of the buttons in px |
    | _button_height_ | height of the buttons in px |
    | _border_width_ | width of the border around the main frame [Default is 1] |
    | _border_color_ | color of the frame border |
    | _cancel_button_ | define the cancel button type: **circle, cross or None** |
    | _cancel_button_color_ | color of the **close** button, **set it to 'transparent' if you want to hide it** |
    | **_icon_** | icon that will be shown in the messagebox [Default is the 'info' icon] |
    | _icon_size_ | define the size of the icon image manually (tuple) |
    | _corner_radius_ | corner roundness of the messagebox window [**not applicable in linux**] |
    | _font_ | font of the messagebox text (tuple) |
    | _header_ | add the original header back if you don't like **overrideredirect** (bool) |
    | _topmost_ | disable the topmost window outside the app (bool) |
    | _sound_ | enable the system bell sound when the window popups (bool) |
    | _justify_ | position the buttons to center/right/left |
    | _focus_option_ | select an option by default when `Enter` key is pressed |
    | **_fade_in_duration_** | enable a fade-in and fade-out animation (int, default is 0)  |


  </div>

  <br>

  <h2 align="center"> Icons </h2>

  <div align="center">

  **Default icons:**

  ![icons](https://user-images.githubusercontent.com/89206401/221258403-aafea575-856e-4f4e-b3af-f995785c9879.png)

  (*These icons are created using Paint.NET, free to use!*)

  **For custom images, just use `icon="image_path.png"`**



  </div>


pkgId: 9c686b7395fd84570d73c07e1afadad84701f4e9f0a036021d5b415d82b6eceb
name: python-CTkTable
arch: src
version: 1.1
epoch: 0
release: 1
summary: Customtkinter Table widget
url: https://github.com/Akascape/CTkTable
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTkTable-1.1-1.src.rpm
checksum_type: sha256
description:
  **Here is a quick and simple table widget having all the basic features.**

  ![Screenshot](https://user-images.githubusercontent.com/89206401/233420929-bf210cb3-5b5f-49b2-ba7a-f01d187e72cf.jpg)


  - Add columns/rows
  - Delete columns/rows
  - Edit rows/columns at once
  - Insert values to specific cell
  - delete values from specific cell
  - update all values at once
  - edit each cell value and options
  - entry editing
  - can be used with scrollable frame
  - Lots of other data operarions


  ```
  pip install CTkTable
  ```





  ```python
  import customtkinter
  from CTkTable import *

  root = customtkinter.CTk()

  value = [[1,2,3,4,5],
           [1,2,3,4,5],
           [1,2,3,4,5],
           [1,2,3,4,5],
           [1,2,3,4,5]]

  table = CTkTable(master=root, row=5, column=5, values=value)
  table.pack(expand=True, fill="both", padx=20, pady=20)

  root.mainloop()
  ```


  - **.insert(row, column, value, *args)**: change specific cell index data
  - **.add_row(index, values)**
  - **.add_column(index, values)**
  - **.edit_row(row_num, *args)**: edit one full row at once
  - **.edit_column(column_num, *args)**: edit one full column at once
  - **.delete_row(index)**: remove one row
  - **.delete_column(index)**: remove one column
  - **.delete_rows(indices)**: remove mutliple rows
  - **.delete_columns(indices)**: remove multiple columns
  - **.edit(row, column)**: edit specific cell without changing the value
  - **.select(row, column)**: select one cell
  - **.select_row(row)**: select a row
  - **.get_selected_row()**: get the values of the selected row
  - **.deselect_row(row)**: deselect a row
  - **.select_column(column)**: select a column
  - **.get_selected_column()**: get the values of selected column
  - **.deselect_column(column)**: deselect a column
  - **.update_values(values)**: update all values at once
  - **.delete(row, column, *args)**: delete the data from specific index
  - **.get()**: get all values
  - **.get(row, column)**: get specific cell value
  - **.get_row(row)**: get all values of a specific row
  - **.get_column(column)**: get all values of a specific column
  - **.configure(arguments)**: change other table attributes

  _here, **args** means ctkbutton parameters which can also be passed_

  **Note: treat all the table cells as a ctkbutton class**


  | Parameter | Description |
  |-----------| ------------|
  | **master** | parent widget  |
  | **values** | the default values for table |
  | row | **optional**, set number of default rows |
  | column | **optional**, set number of default columns |
  | padx | add internal padding in x |
  | pady | add internal padding in y |
  | colors | set two fg_colors for the table (list), eg: `colors=["yellow", "green"]` |
  | color_phase | set color phase based on rows or columns, eg: `color_phase="vertical"` |
  | orientation | change the orientation of table, `vertical or horizontal` |
  | header_color | define the topmost row color |
  | corner_radius | define the corner roundness of the table |
  | hover_color | enable hover effect on the cells |
  | wraplength | set the width of cell text |
  | justify | anchor the position of the cell text |
  | **command** | specify a command when a table cell is pressed, [returns row, column, value] |
  | **other button parameters* | all other ctk button parameters can be passed |

  Note: This library is at early stage so there can be some performance issues.


pkgId: db5c5a5ec5c5a2a889df67f6d8af4ac310d97726399b1602615adb208b604fec
name: python-CTkToolTip
arch: src
version: 0.8
epoch: 0
release: 1
summary: Customtkinter Tooltip widget
url: https://github.com/Akascape/CTkToolTip
rpm_license: Creative Commons Zero v1.0 Universal
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CTkToolTip-0.8-1.src.rpm
checksum_type: sha256
description:
  **Small tooltip pop-up label for displaying details on customtkinter widgets.**

  ![example](https://user-images.githubusercontent.com/89206401/229771216-199727ef-2a01-4ab3-bac6-7e0a5234389e.gif)


  - Display over any CTk widget
  - Configurable options
  - Transparency effect
  - Round corners
  - Can be used with CTkSlider to show the value
  - Dynamic offset
  - Add delays



  ```
  pip install CTkToolTip
  ```




  **Simple Usage:**
  ```python
  CTkToolTip(widget, message="Your Message")
  ```
  **App Example:**
  ```python
  import customtkinter
  from CTkToolTip import *

  def show_value(value):
      tooltip_1.configure(message=int(value))

  def show_text():
      print(tooltip_2.get())

  root = customtkinter.CTk()

  slider = customtkinter.CTkSlider(root, from_=0, to=100, command=show_value)
  slider.pack(fill="both", padx=20, pady=20)

  tooltip_1 = CTkToolTip(slider, message="50")

  button = customtkinter.CTkButton(root, command=show_text)
  button.pack(fill="both", padx=20, pady=20)

  tooltip_2 = CTkToolTip(button, delay=0.5, message="This is a CTkButton!")

  root.mainloop()
  ```


  | Parameter | Description |
  |-----------| ------------|
  | **widget** | bind the tooltip to the ctk widget |
  | **message** | show the message over the toolip |
  | **delay** | add a small delay before showing the tooltip (default is 0.2) |
  | follow | follow the mouse cursor while hovering (default is True) |
  | x_offset | change the horizontal offset of the tooltip widget from mouse cursor |
  | y_offset | change the vertical offset of the tooltip widget from mouse cursor |
  | **alpha** | change the transparency effect of the tooltip (range: 0-1) |
  | **bg_color** | change the background color of the tooltip |
  | corner_radius | roundness of the corners |
  | border_width | add a border around the tooltips (default is 0) |
  | border_color | change the color of the border width |
  | padding | add padx and pady inside the tooltip frame, tuple: (padx, pady) |
  | **text_color** | change the text color of tooltip |
  | wraplength | constrains the width of the tooltip, causing CTkToolTip, where required, to wrap the message at word boundaries. |
  | font | label text font, tuple: (font_name, size) |
  | justify | change the text display structure (left, right or center) |
  | _*Other Label Parameters_ | _All other parameters for ctk label can be passed in ctktooltip_ |



  - **.configure(message, arguments...)**

     configure the text and other parameters for the tooltip
  - **.get()**

     get the current text of tooltip
  - **.hide()**

     disables the tooltip from appearing
  - **.show()**

     enable the tooltip again
  - **.is_disabled()**

     check the tooltip state


pkgId: 8cc17aea830c19356f1e504c4a118e9c55d4d68d6d1b33160917a09625864219
name: python-CURPSuite
arch: src
version: 2.6.1
epoch: 0
release: 1
summary: Análisis y validación de la CURP Mexicana
url: https://curpsuite.readthedocs.io
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CURPSuite-2.6.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version][version-badge]][pypi] [![Python versions][python-version-badge]][pypi] [![License: GPL  v2][license-badge]][gnu] [![Build][build-badge]][actions] [![ReadTheDocs][docs-badge]][rtd] [![Total downloads][downloads-badge]][pepy]

  **CURP Suite** es una librería de análisis y validación de la CURP Mexicana.

  ```python
  >>> from curp import CURP
  >>> c = CURP("SABC560626MDFLRN01")
  >>> c.fecha_nacimiento
  datetime.date(1956, 6, 26)
  >>> c.sexo
  <Sexo.MUJER: 2>
  >>> c.entidad
  'Ciudad de México'
  >>> c.nombre_valido("Concepción")
  True

  ```



  CURP Suite te permite extraer toda la información que contiene una CURP de forma conveniente. Además, toda la validación es automática. CURP Suite está diseñado para dar soporte a toda la especificación oficial de la CURP.

  También puede ser invocada desde la terminal

  ```bash
  $ curp SABC560626MDFLRN01
  {"curp": "SABC560626MDFLRN01", "sexo": 2, "fecha_nacimiento": "1956-06-26", "entidad_nacimiento": {"name": "Ciudad de México", "iso": "MX-CMX"}}
  ```









  ```bash
  $ python3 -m pip install CURPSuite
  ```

  CURP Suite soporta Python 3.8+.





  - Extracción de datos
    - Fecha de nacimiento como objeto `datetime.date`
    - Sexo compatible con [ISO/IEC 5218][iso5218]
    - Nombre y clave [ISO 3166-2][iso3166] de la entidad federativa de nacimiento
  - Representación JSON de datos extraídos
  - Validación con nombres y apellidos
  - Validación con nombre completo
  - Interfaz de Línea de Comandos





  Disponible en https://curpsuite.readthedocs.io.





  Este programa se distribuye bajo la licencia [GPLv2.0][license], más información en el sitio de la [Free Software Foundation][gnu].



  <!-- MARKDOWN LINK REFERENCES -->

  [iso5218]: https://en.wikipedia.org/wiki/ISO/IEC_5218 "ISO/IEC 5218"
  [iso3166]: https://es.wikipedia.org/wiki/ISO_3166-2 "ISO 3166-2"
  [git]: https://git-scm.com/	"Git"
  [python]: https://www.python.org/ "Python.org"
  [pipenv]: https://pipenv.pypa.io/en/latest/ "Pipenv"
  [license]: LICENSE "General Public License"
  [gnu]: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html "Free Software Foundation"
  [pypi]: https://pypi.org/project/CURPSuite
  [license-badge]: https://img.shields.io/github/license/jacobszpz/CURPSuite
  [version-badge]: https://img.shields.io/pypi/v/CURPSuite
  [python-version-badge]: https://img.shields.io/pypi/pyversions/CURPSuite
  [build-badge]: https://img.shields.io/github/actions/workflow/status/jacobszpz/CURPSuite/integration.yml?branch=master
  [actions]: https://github.com/jacobszpz/CURPSuite/actions
  [docs-badge]: https://img.shields.io/readthedocs/curpsuite
  [rtd]: https://curpsuite.readthedocs.io
  [rtd-changelog]: https://curpsuite.readthedocs.io/es/latest/CHANGELOG.html
  [downloads-badge]: https://static.pepy.tech/badge/curpsuite
  [pepy]: https://pepy.tech/project/curpsuite
  [pypi-stats]: https://pypistats.org/packages/curpsuite


pkgId: 5f25d16a96cade9a18ec98786cb73c4c4f0401835c560c0f4ae7546a2045eb1e
name: python-CVAugmentor
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: A package for augmenting images and videos for computer vision tasks
url: https://github.com/AliKHaliliT/CVAugmentor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CVAugmentor-1.0.12-1.src.rpm
checksum_type: sha256
description:
  This is a simple tool to augment images and videos for computer vision tasks.

  Available augmentations are:
      no_augmentation,
      flip,
      zoom,
      rotate,
      shear,
      grayscale,
      hue,
      saturation,
      brightness,
      exposure,
      blur,
      noise,
      cutout,
      negative.

  You can install the package using pip:
  ```bash
  pip install CVAugmentor
  ```

  For a detailed usage guide, please refer to the [documentation](https://alikhalilit.github.io/CVAugmentor/).

  ```python

  from CVAugmentor import Augmentations as aug
  from CVAugmentor import Pipeline



  augmentations = {
      "zoom": aug.zoom(),
      "flip": aug.flip(),
  }


  p = Pipeline()


  p.augment(input_path="path/to/input_image", output_path="path/to/output_image", target="image", process_type="single", mode="singular", augmentations=augmentations, aug_verbose=True)
  ```

  ```python

  from CVAugmentor import Augmentations as aug
  from CVAugmentor import Pipeline



  augmentations = {
      "zoom": aug.zoom(),
      "flip": aug.flip(),
  }


  p = Pipeline()


  p.augment(input_path="path/to/input_video", output_path="path/to/output_video", target="video", process_type="single", mode="singular", augmentations=augmentations, aug_verbose=True)
  ```

  ```python

  from CVAugmentor import Augmentations as aug
  from CVAugmentor import Pipeline



  augmentations = {
      "zoom": aug.zoom(),
      "flip": aug.flip(),
  }


  p = Pipeline()


  p.augment(input_path="path/to/input_images", output_path="path/to/output_images", target="image", process_type="batch", mode="singular", augmentations=augmentations, verbose=True, warn_verbose=True)
  ```

  ```python

  from CVAugmentor import Augmentations as aug
  from CVAugmentor import Pipeline



  augmentations = {
      "zoom": aug.zoom(),
      "flip": aug.flip(),
  }


  p = Pipeline()


  p.augment(input_path="path/to/input_videos", output_path="path/to/output_videos", target="video", process_type="batch", mode="singular", augmentations=augmentations, verbose=True, warn_verbose=True)
  ```

  This work is under an [MIT](https://choosealicense.com/licenses/mit/) License.


pkgId: 00c11ae9fe82b2a24f98c084acae594a77dfe1e4edd67a2442835c6a1c361e7c
name: python-CVPubSubs
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/SimLeek/CV_PubSubs
rpm_license: MIT/Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CVPubSubs-0.6.5-1.src.rpm
checksum_type: sha256
description:
  A  threaded PubSub OpenCV interfaceREADME.md. Webcam and video feeds to multiple windows is supported.



  CVPubSubs is distributed on `PyPI <https://pypi.org>`_ as a universal
  wheel and is available on Linux/macOS and Windows and supports
  Python 2.7/3.5+ and PyPy.

      $ pip install CVPubSubs






      import cvpubsubs.webcam_pub as w

      w.VideoHandlerThread().display()


      import cvpubsubs.webcam_pub as w

      video_thread = w.VideoHandlerThread(video_source=0,
                                          callbacks = w.display_callbacks,
                                          request_size=(800, 600),
                                          high_speed = False,
                                          fps_limit = 8
                                          )


      import cvpubsubs.webcam_pub as w
      from cvpubsubs.input import mouse_loop

      @mouse_loop
      def print_mouse(mouse_event):
          print(mouse_event)

      w.VideoHandlerThread().display()


      import cvpubsubs.webcam_pub as w
      from cvpubsubs.input import key_loop

      @key_loop
      def print_key_thread(key_chr):
          print("key pressed: " + str(key_chr))

      w.VideoHandlerThread().display()


      import cvpubsubs.webcam_pub as w

      def redden_frame_print_spam(frame, cam_id):
          frame[:, :, 0] = 0
          frame[:, :, 1] = 0
          print("Spam!")

      w.VideoHandlerThread(callbacks=[redden_frame_print_spam] + w.display_callbacks).display()



      def tensor_from_image(frame, cam_id):
          ten = tensor_from_pytorch_or_tensorflow(frame)
          return ten

      t = wp.VideoHandlerThread(video_source=cam, callbacks=[tensor_from_image] + wp.display_callbacks)

      t.display()


      import cvpubsubs.webcam_pub as w
      from cvpubsubs.window_sub import SubscriberWindows

      def cam_handler(frame, cam_id):
          SubscriberWindows.set_global_frame_dict(cam_id, frame, frame)

      t = w.VideoHandlerThread(0, [cam_handler],
                               request_size=(1280, 720),
                               high_speed=True,
                               fps_limit=240
                               )

      t.start()

      SubscriberWindows(window_names=['cammy', 'cammy2'],
                        video_sources=[str(0)]
                        ).loop()

      t.join()


      iport cvpubsubs.webcam_pub as w
      from cvpubsubs.window_sub import SubscriberWindows

      t1 = w.VideoHandlerThread(0)
      t2 = w.VideoHandlerThread(1)

      t1.start()
      t2.start()

      SubscriberWindows(window_names=['cammy', 'cammy2'],
                        video_sources=[0,1]
                        ).loop()

      t1.join()
      t1.join()


      from cvpubsubs.webcam_pub import VideoHandlerThread
      from cvpubsubs.webcam_pub.callbacks import function_display_callback
      img = np.zeros((50, 50, 1))
      img[0:5, 0:5, :] = 1

      def conway_game_of_life(array, coords, finished):
          neighbors = np.sum(array[max(coords[0] - 1, 0):min(coords[0] + 2, 50),
                             max(coords[1] - 1, 0):min(coords[1] + 2, 50)])
          neighbors = max(neighbors - np.sum(array[coords[0:2]]), 0.0)
          if array[coords] == 1.0:
              if neighbors < 2 or neighbors > 3:
                  array[coords] = 0.0
              elif 2 <= neighbors <= 3:
                  array[coords] = 1.0
          else:
              if neighbors == 3:
                  array[coords] = 1.0

      VideoHandlerThread(video_source=img, callbacks=function_display_callback(conway_game_of_life)).display()



  CVPubSubs is distributed under the terms of both

  - `MIT License <https://choosealicense.com/licenses/mit>`_
  - `Apache License, Version 2.0 <https://choosealicense.com/licenses/apache-2.0>`_

  at your option.


pkgId: 2108c60d419df5ef3982a19680b8949dfe1b6ea8f194c8998a80de9a0a7c274c
name: python-CVX2
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Tools of CV(Computer Vision)
url: https://gitee.com/summry/sklearntools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CVX2-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

          import torch
          from torch import nn
          from cvx2 import WidthBlock

          model = nn.Sequential(
              WidthBlock(c1=1, c2=32),
              nn.MaxPool2d(kernel_size=2, stride=2),
              WidthBlock(c1=32, c2=64),
              nn.MaxPool2d(kernel_size=2, stride=2),
              nn.Flatten(),
              nn.Linear(in_features=64*49, out_features=1024),
              nn.Dropout(0.2),
              nn.SiLU(inplace=True),
              nn.Linear(in_features=1024, out_features=2),
          )

          img = torch.randn(1, 1, 28, 28)
          print(model(img).shape)


pkgId: af4a7963faf989c7fa00a15584c981305a5c95181e610899882e3368e8d4e22d
name: python-CVX2
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Tools of CV(Computer Vision)
url: https://gitee.com/summry/cvx2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CVX2-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

          import torch
          from torch import nn
          from cvx2 import WidthBlock
          from cvx2.wrapper import ImageClassModelWrapper

          model = nn.Sequential(
              WidthBlock(c1=1, c2=32),
              nn.MaxPool2d(kernel_size=2, stride=2),
              WidthBlock(c1=32, c2=64),
              nn.MaxPool2d(kernel_size=2, stride=2),
              nn.Flatten(),
              nn.Linear(in_features=64*49, out_features=1024),
              nn.Dropout(0.2),
              nn.SiLU(inplace=True),
              nn.Linear(in_features=1024, out_features=2),
          )

          img = torch.randn(1, 1, 28, 28)
          print(model(img).shape)

          data_dir
           |__train
           |   |__class1
           |   |   |__001.jpg
           |   |   |__002.jpg
           |   |__class2
           |      |__001.jpg
           |      |__002.jpg
           |__test
           |   |__class1
           |   |   |__001.jpg
           |   |   |__002.jpg
           |   |__class2
           |      |__001.jpg
           |      |__002.jpg
           |__val
               |__class1
               |   |__001.jpg
               |   |__002.jpg
               |__class2
                  |__001.jpg
                  |__002.jpg

          model_wrapper = ImageClassModelWrapper(model)
          model_wrapper.train(data='data_dir', imgsz=28)
          result = model_wrapper.predict('data_dir/test/class1/001.jpg', imgsz=28)


pkgId: 269f0819668f58da5fd88c7cee3050ecfd339b41ecef29ffec2be7c195115dda
name: python-CWR-API
arch: src
version: 0.0.40
epoch: 0
release: 1
summary: API library for the CWR standard format
url: https://github.com/weso/CWR-DataApi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CWR-API-0.0.40-1.src.rpm
checksum_type: sha256
description:
  This projects offers a domain model for the CISAC CWR standard v2.1 to be
  used on Python applications, along a series of parsing which allow
  transformations between the model and various data structures.
  CWR stands for Common Works Registration, and it is a common or standard
  format for the registration and revision of musical works, used by
  publishers and performing rights societies as a way to exchange musical
  works data.
  While the CWR standard has been created by `CISAC`_ this library has been
  developed by `WESO`_ independently, with help from `BMAT`_.


pkgId: 8feda1944b6909454515f6dd3065a104450e118886a8cf9aeb39b5866c32144c
name: python-CaGeo
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Package description
url: https://github.com/USERNAME/project
rpm_license: BSD-Clause-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CaGeo-0.1.0-1.src.rpm
checksum_type: sha256
description:
  In this repository we want to collect and implement methods to extract
  from a set of raw GPS coordinates features that enrich the dataset,
  but which, simultaneously also allow dimensionality reduction.




  - Speed: AVG, STD, MIN, MAX
  - Acceleration: AVG, STD, MIN, MAX
  - angle/direction: atan2 == Bearing: angle between the magnetic north and an object ??


  - Turning Angle: AVG, STD, MIN, MAX. 𝐻𝐶𝑅 = |𝑃𝑐|/𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑒 Pc is the collection of gps points at which a user changes
     his/her heading direction exceeding a certain threshold (Hc), and |𝑃𝑐 | represents the number of elements in Pc
  - Traveled Distance: SUM
  - Stop Rate: 𝑆𝑅 = |𝑃𝑠|/𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑒 Ps is the collection of point with velocity smaller than a certain threshold
  - Velocity Change Rate: foreach point 𝑝1. 𝑉𝑅𝑎𝑡𝑒 = |𝑉2 − 𝑉1|/𝑉1; then 𝑉𝐶𝑅 = |𝑃𝑣|/𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑒 where 𝑃𝑣 ={𝑝𝑖|𝑝𝑖 ∈ 𝑃, 𝑝𝑖 . 𝑉𝑅𝑎𝑡𝑒 > 𝑉𝑟 }
  - FFT?
  - duration of movement?
  - traveled path?
  - displacement?
  - Bearing rate: B_rate(i+1) = (Bi+1 − Bi)/∆t
  - Rate of bearing rate: Br_rate(i+1) = (Brate(i+1) − Brate(i))/∆t


  - sinuosity ?
  - distance from POI


  - A survey and comparison of trajectory classification methods
  - Understanding mobility based on GPS data
  - Revealing the physics of movement: comparing the similarity of movement characteristics of different types of moving objects
  - Predicting Transportation Modes of GPS Trajectories using Feature Engineering and Noise Removal
  - Determination transportation mode on mobile phones




  Per le distanze vedere Intelligent Trajectory Classification for Improved Movement Prediction

  In "Identifying Different Transportation Modes from Trajectory Data Using Tree-Based Ensamble Classifier": ci sono varie misure globali


pkgId: f79d056b367c1cc222589827fce33299f8cd6f96f216192cc813d802471afd4a
name: python-CacheToolsUtils
arch: src
version: 10.0
epoch: 0
release: 1
summary: Cachetools Utilities
url: https://pypi.org/project/CacheToolsUtils/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CacheToolsUtils-10.0-1.src.rpm
checksum_type: sha256
description:
  Classes to add key prefix and stats to
  [cachetools](https://pypi.org/project/cachetools/) classes and use
  [redis](https://redis.io/) and
  [memcached](https://memcached.org/) as storage backends,
  and other cache-related utils.

  ![Status](https://github.com/zx80/cachetools-utils/actions/workflows/cachetools-utils.yml/badge.svg?branch=main&style=flat)
  ![Tests](https://img.shields.io/badge/tests-22%20✓-success)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-success)
  ![Issues](https://img.shields.io/github/issues/zx80/cachetools-utils?style=flat)
  ![Python](https://img.shields.io/badge/python-3-informational)
  ![Version](https://img.shields.io/pypi/v/CacheToolsUtils)
  ![Badges](https://img.shields.io/badge/badges-8-informational)
  ![License](https://img.shields.io/pypi/l/cachetoolsutils?style=flat)



  For our purpose, a cache is a key-value store, aka a dictionary, possibly with
  some constraints on keys (type, size) and values (size, serialization).
  This module provides new caches, wrappers and other utilities suitable to use
  with `cachetools`.



  - `RedisCache` allows to see a Redis server as a python cache
    by wrapping a `redis.Redis` instance.
  - `MemCached` does the same for a Memcached server.
    The utility class `JsonSerde` is a convenient JSON serializer-deserializer
    class for Memcached.
  - `DictCache` a very simple `dict` cache.



  - `PrefixedCache`, `PrefixedMemCached` and `PrefixedRedisCache` add a prefix to
    distinguish sources on a shared cache.
  - `StatsCache`, `MemCached` and `RedisCache` add a `hits` method
    to report the cache hit rate, `stats` to report statistics and
    `reset` to reset statistics.
  - `LockedCache` use a (thread) lock to control cache accesses.
  - `TwoLevelCache` allows to combine two caches.
  - `DebugCache` to trace cache calls using `logging`.
  - `EncryptedCache` a cache with key hashing and value encryption.
  - `ToBytesCache` map keys and values to bytes.



  - `cached` decorator: a cachetools replacement which allows to test if a
    function result is in cache, and to delete such an entry.
  - `cacheFunctions` and `cacheMethods`: add caching to functions or methods.
  - `json_key`, `hash_json_key`, `full_hash_key`: convenient JSON-based cache key
    serialization functions for `cached`.



  This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).

  All software has bug, this is software, hence… Beware that you may lose your
  hairs or your friends because of it. If you like it, feel free to send a
  postcard to the author.



  See the
  [documentation](https://zx80.github.io/cachetools-utils/),
  [sources](https://github.com/zx80/cachetools-utils) and
  [issues](https://github.com/zx80/cachetools-utils/issues) on GitHub.

  See [packages](https://pypi.org/project/CacheToolsUtils/) on PyPI.


pkgId: 004ac18dd97b6f984553c93527c63534d9d449165f13b5befce9ba928a351747
name: python-CacheToolsUtils
arch: src
version: 8.6
epoch: 0
release: 1
summary: Cachetools Utilities
url: https://pypi.org/project/CacheToolsUtils/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CacheToolsUtils-8.6-1.src.rpm
checksum_type: sha256
description:
  Classes to add key prefix and stats to
  [cachetools](https://pypi.org/project/cachetools/) classes and use
  [redis](https://redis.io/) and
  [memcached](https://memcached.org/) as storage backends,
  and other cache-related utils.

  ![Status](https://github.com/zx80/cachetools-utils/actions/workflows/cachetools-utils.yml/badge.svg?branch=main&style=flat)
  ![Tests](https://img.shields.io/badge/tests-17%20✓-success)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-success)
  ![Issues](https://img.shields.io/github/issues/zx80/cachetools-utils?style=flat)
  ![Python](https://img.shields.io/badge/python-3-informational)
  ![Version](https://img.shields.io/pypi/v/CacheToolsUtils)
  ![Badges](https://img.shields.io/badge/badges-8-informational)
  ![License](https://img.shields.io/pypi/l/cachetoolsutils?style=flat)



  For our purpose, a cache is a key-value store, aka a dictionary, possibly with
  some constraints on keys (type, size) and values (size, serialization).
  This module provides new caches, wrappers and other utilities suitable to use
  with `cachetools`.



  - `RedisCache` allows to see a Redis server as a python cache
    by wrapping a `redis.Redis` instance.
  - `MemCached` does the same for a Memcached server.
    The utility class `JsonSerde` is a convenient JSON serializer-deserializer
    class for Memcached.
  - `DictCache` a very simple `dict` cache.



  - `PrefixedCache`, `PrefixedMemCached` and `PrefixedRedisCache` add a prefix to
    distinguish sources on a shared cache.
  - `StatsCache`, `StatsMemCached` and `StatsRedisCache` add a `hits()` method
    to report the cache hit rate.
  - `LockedCache` use a (thread) lock to control cache accesses.
  - `TwoLevelCache` allows to combine two caches.
  - `DebugCache` to trace cache calls using `logging`.



  - `cached` decorator: a cachetools replacement which allows to test if a
    function result is in cache, and to delete such an entry.
  - `cacheFunctions` and `cacheMethods`: add caching to functions or methods.



  This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).

  All software has bug, this is software, hence… Beware that you may lose your
  hairs or your friends because of it. If you like it, feel free to send a
  postcard to the author.



  See the
  [documentation](https://zx80.github.io/cachetools-utils/),
  [sources](https://github.com/zx80/cachetools-utils) and
  [issues](https://github.com/zx80/cachetools-utils/issues) on GitHub.

  See [packages](https://pypi.org/project/CacheToolsUtils/) on PyPI.


pkgId: c07d34522ac516f9a214291b50eda361c8546d72283a905289239e1211f69890
name: python-CacheToolsUtils
arch: src
version: 9.0
epoch: 0
release: 1
summary: Cachetools Utilities
url: https://pypi.org/project/CacheToolsUtils/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CacheToolsUtils-9.0-1.src.rpm
checksum_type: sha256
description:
  Classes to add key prefix and stats to
  [cachetools](https://pypi.org/project/cachetools/) classes and use
  [redis](https://redis.io/) and
  [memcached](https://memcached.org/) as storage backends,
  and other cache-related utils.

  ![Status](https://github.com/zx80/cachetools-utils/actions/workflows/cachetools-utils.yml/badge.svg?branch=main&style=flat)
  ![Tests](https://img.shields.io/badge/tests-19%20✓-success)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-success)
  ![Issues](https://img.shields.io/github/issues/zx80/cachetools-utils?style=flat)
  ![Python](https://img.shields.io/badge/python-3-informational)
  ![Version](https://img.shields.io/pypi/v/CacheToolsUtils)
  ![Badges](https://img.shields.io/badge/badges-8-informational)
  ![License](https://img.shields.io/pypi/l/cachetoolsutils?style=flat)



  For our purpose, a cache is a key-value store, aka a dictionary, possibly with
  some constraints on keys (type, size) and values (size, serialization).
  This module provides new caches, wrappers and other utilities suitable to use
  with `cachetools`.



  - `RedisCache` allows to see a Redis server as a python cache
    by wrapping a `redis.Redis` instance.
  - `MemCached` does the same for a Memcached server.
    The utility class `JsonSerde` is a convenient JSON serializer-deserializer
    class for Memcached.
  - `DictCache` a very simple `dict` cache.



  - `PrefixedCache`, `PrefixedMemCached` and `PrefixedRedisCache` add a prefix to
    distinguish sources on a shared cache.
  - `StatsCache`, `MemCached` and `RedisCache` add a `hits` method
    to report the cache hit rate, `stats` to report statistics and
    `reset` to reset statistics.
  - `LockedCache` use a (thread) lock to control cache accesses.
  - `TwoLevelCache` allows to combine two caches.
  - `DebugCache` to trace cache calls using `logging`.



  - `cached` decorator: a cachetools replacement which allows to test if a
    function result is in cache, and to delete such an entry.
  - `cacheFunctions` and `cacheMethods`: add caching to functions or methods.



  This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).

  All software has bug, this is software, hence… Beware that you may lose your
  hairs or your friends because of it. If you like it, feel free to send a
  postcard to the author.



  See the
  [documentation](https://zx80.github.io/cachetools-utils/),
  [sources](https://github.com/zx80/cachetools-utils) and
  [issues](https://github.com/zx80/cachetools-utils/issues) on GitHub.

  See [packages](https://pypi.org/project/CacheToolsUtils/) on PyPI.


pkgId: 77312dc1e59974b21b9ae5019069c58016ac9adfe9ec96db9993dc48a9f38315
name: python-CacheToolsUtils
arch: src
version: 9.2
epoch: 0
release: 1
summary: Cachetools Utilities
url: https://pypi.org/project/CacheToolsUtils/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CacheToolsUtils-9.2-1.src.rpm
checksum_type: sha256
description:
  Classes to add key prefix and stats to
  [cachetools](https://pypi.org/project/cachetools/) classes and use
  [redis](https://redis.io/) and
  [memcached](https://memcached.org/) as storage backends,
  and other cache-related utils.

  ![Status](https://github.com/zx80/cachetools-utils/actions/workflows/cachetools-utils.yml/badge.svg?branch=main&style=flat)
  ![Tests](https://img.shields.io/badge/tests-21%20✓-success)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-success)
  ![Issues](https://img.shields.io/github/issues/zx80/cachetools-utils?style=flat)
  ![Python](https://img.shields.io/badge/python-3-informational)
  ![Version](https://img.shields.io/pypi/v/CacheToolsUtils)
  ![Badges](https://img.shields.io/badge/badges-8-informational)
  ![License](https://img.shields.io/pypi/l/cachetoolsutils?style=flat)



  For our purpose, a cache is a key-value store, aka a dictionary, possibly with
  some constraints on keys (type, size) and values (size, serialization).
  This module provides new caches, wrappers and other utilities suitable to use
  with `cachetools`.



  - `RedisCache` allows to see a Redis server as a python cache
    by wrapping a `redis.Redis` instance.
  - `MemCached` does the same for a Memcached server.
    The utility class `JsonSerde` is a convenient JSON serializer-deserializer
    class for Memcached.
  - `DictCache` a very simple `dict` cache.



  - `PrefixedCache`, `PrefixedMemCached` and `PrefixedRedisCache` add a prefix to
    distinguish sources on a shared cache.
  - `StatsCache`, `MemCached` and `RedisCache` add a `hits` method
    to report the cache hit rate, `stats` to report statistics and
    `reset` to reset statistics.
  - `LockedCache` use a (thread) lock to control cache accesses.
  - `TwoLevelCache` allows to combine two caches.
  - `DebugCache` to trace cache calls using `logging`.



  - `cached` decorator: a cachetools replacement which allows to test if a
    function result is in cache, and to delete such an entry.
  - `cacheFunctions` and `cacheMethods`: add caching to functions or methods.
  - `json_key` and `hash_json_key`: JSON-based cache key serialization functions



  This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).

  All software has bug, this is software, hence… Beware that you may lose your
  hairs or your friends because of it. If you like it, feel free to send a
  postcard to the author.



  See the
  [documentation](https://zx80.github.io/cachetools-utils/),
  [sources](https://github.com/zx80/cachetools-utils) and
  [issues](https://github.com/zx80/cachetools-utils/issues) on GitHub.

  See [packages](https://pypi.org/project/CacheToolsUtils/) on PyPI.


pkgId: 1fe3ef50175ac345f1c6c3b801fee15a662fcc63e45285c8e5a78a1b61851af7
name: python-Cactool
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: An easy way to collaboratively code social media posts for manual content and discourse analysis
url: https://cactool.github.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cactool-0.6.2-1.src.rpm
checksum_type: sha256
description:
  <a href="#readme">![Cactool](https://i.imgur.com/XooF3N8.png)</a>


  <p align="center">
   <a href="https://badge.fury.io/py/Cactool">
    <img src="https://badge.fury.io/py/Cactool.svg" alt="PyPI version">
   </a>
    <a href="https://cactool.readthedocs.io">
    <img src="https://readthedocs.org/projects/cactool/badge/?version=latest&style=flat" alt="docs">
   </a>
    <a href="https://github.com/mkenney/software-guides/blob/master/STABILITY-BADGES.md#beta">
    <img src="https://img.shields.io/badge/stability-beta-33bbff.svg" alt="stability-beta">
   </a>
    <a href="">
    <img src="https://github.com/cactool/cactool/workflows/CodeQL/badge.svg" alt="CodeQL">
   </a>
   </p>


  Cactool (or Content Analysis Coding Tool) is a platform which allows researchers to collaboratively code pre-existing social media datasets in their native format for manual content and discourse analysis.

  Using Cactool is easy, after the initial installation, you can create users, import your data, set your coding variables, and get started! This allows coders, especially those working in groups, to analyse social media data quicker, more accessibly, and more accurately by viewing posts in context.



  - **No more coding via spreadsheets:** Coding via your browser (tested working on Chrome, Firefox, Edge, & Safari) with posts visible as they would be on the social media platform. This allows your coders to evaluate social media content in their native format.
  - **Simple Import and Export:** Take your pre-existing social media URLs from software such as [4Cat](https://github.com/digitalmethodsinitiative/4cat), [NodeXL](https://www.smrfoundation.org/nodexl/), or API Scrapers such as [Tweepy](https://www.tweepy.org/) and import them as a CSV list. When done, you can export your data via CSV to whatever analysis software you desire.
  - **Importing of image/text data:** Have data from secondary source with no URLs? No Problem.
  - **Manage Multiple Datasets:** Want to split your project by source/themes? You can manage multiple concurrent datasets at the same time.
  - **Built for collaboration:** Cactool comes pre-packaged with user management; codes attributed are attributed to each coder for coder reliability calculation (such as [ReCal](http://dfreelon.org/utils/recalfront/)). Multiple people can be coding at the same time without sharing documents. No need to worry about version control or splitting up data.
  - **Code on the Go:** Cactool is mobile friendly and can be accessed remotely (we recommend using a VPN to connect, see our tutorial for why). This provides researchers interested in social media content and spaciality new avenues of research.



  Cactool works for across multiple-social media platforms. The following data types are currently supported:
  - Twitter
  - YouTube
  - TikTok
  - Instagram
  - Mastodon (via OEmbed)
  - Image Data (Photos/screenshots)
  - Text Strings
  - & Some* compatibility with other OEmbed platforms



  Easy to follow installation instructions and user guides can be found via the documentation on [Read the Docs](https://cactool.readthedocs.io)


  You can install Cactool on your local machine or on a server through [Docker](https://www.docker.com/) or directly using [PIP (package manager)](https://pip.pypa.io/en/stable/). Running Cactool through a server is useful if you want to have multiple coders, or want to code through your mobile while situated away from your main computer.

  Cactool also has some custom build configurations



  Note that on Windows, you may need to ensure that WSL (Windows Subsystem for Linux) integration is enabled in Docker. You can find this in the Docker setting in Settings -> Resources-> WSL Integration -> Enable integration with required distros.

  ```bash
  git clone https://github.com/cactool/cactool
  ```

  ```
  cd cactool
  ```

  Make sure the Docker daemon is running then run
  ```bash
  docker-compose up -d
  ```
  An instance should be accessible on port 80



  ```bash
  pip install cactool
  ```

  ```bash
  cactool
  ```
  The server will be running on port 80 and configuration files can be found in the generated `docker-config` folder.


  There are some additional configuration settings available. For example those aimed at low-memory machines (such as installing Cactool on a Raspberry Pi), or server users with a public facing instance (such as custom ports, limiting file size uploads, and limiting user-signups. Please read the documents for more.


  The project’s Principle Investigator is [Dr Liam McLoughlin](https://Leelum.com), *Lecturer in Media & Communication at the University of Liverpool*, and development was undertaken by [Sam Ezeh](https://github.com/dignissimus)

  Cactus image created by catalyststuff [on Freepik](https://www.freepik.com/author/catalyststuff)


  Cactool Development was funded by the University of Liverpool’s Research Development and Initiative Fund (RDIF).

  ![UoL - Logo - CMYK](https://user-images.githubusercontent.com/11173283/210178161-3070e2df-68a8-4128-8b1b-43453571c85b.png)






  ```bibtex
  @software{McLoughlin_Ezeh_2022,
    title = {{Cactool: An easy way to collaboratively code social media posts for manual content and discourse analysis (BETA)}},
    author  = {McLoughlin, Liam and Ezeh, Sam},
    year  = {2022},
    doi = {10.5281/zenodo.6070206},
    url = {https://github.com/cactool/cactool},
    license = {MIT}
  }
  ```

  ```
  McLoughlin, L., & Ezeh, S. (2022). Cactool: An easy way to collaboratively code social media posts for manual content and discourse analysis (BETA). [Computer software]. URL:https://github.com/cactool/cactool
  ```


  ![Importing from CSV and setting the coding questions made easy](https://user-images.githubusercontent.com/11173283/191358197-1119d00b-5088-485e-9d13-726da1c9708c.png)



  ![Coding & Exporting of data](https://user-images.githubusercontent.com/11173283/191358390-9b903d61-161a-44ea-8bb8-8bc060c520bd.png)



  ![Multiple data types](https://user-images.githubusercontent.com/11173283/191358480-d46348c7-fd74-4378-b952-7a16c01aa82e.png)




  If you've used or cited Cactool in your research, please let us know and we will highlight your paper below. It also helps us understand who and how it's being used!
  - The development of Cactool has also resulted in features being added to Python 3.11. ["bpo-14265: Adds fully qualified test name to unittest output (GH-32138)"](https://github.com/python/cpython/commit/755be9b1505af591b9f2ee424a6525b6c2b65ce9)


pkgId: bf2ffda4c41904876b8862645c32902014ced79cabe38354212045fd327c366d
name: python-CairoSVG
arch: src
version: 2.7.1
epoch: 0
release: 1
summary: A Simple SVG Converter based on Cairo
url: https://courtbouillon.org/cairosvg
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CairoSVG-2.7.1-1.src.rpm
checksum_type: sha256
description:
  CairoSVG is an SVG converter based on Cairo. It can export SVG files to PDF,
  EPS, PS, and PNG files.

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

  CairoSVG 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 CairoSVG. Unless explicitly stated otherwise, any
  contribution intentionally submitted for inclusion is licensed under the LGPL
  license, without any additional terms or conditions. For full
  authorship information, see the version control history.


pkgId: e610f8582031279f5aab593f8698184e92d65848836bc512314f24291672cc90
name: python-CalSciPy
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A toolbox for analyzing, designing, and visualizing multiphoton imaging & optogenetics experiments.
url: https://pypi.org/project/CalSciPy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CalSciPy-0.8.3-1.src.rpm
checksum_type: sha256
description:
  ![Alt text](/docs/images/dancing_neuron_band.png?raw=true)



  <!-- Line 1 Badges... PyPi, Downloads, Maintained, Coverage, Documentation -->
  <!-- Line 2 Badges... Python Versions, PyPi Status, License, Contributors -->
  ![PyPI](https://img.shields.io/pypi/v/CalSciPy)
  ![Maintenance](https://img.shields.io/maintenance/yes/2023)
  [![Coverage Status](https://coveralls.io/repos/github/darikoneil/CalSciPy/badge.svg?branch=master)](https://coveralls.io/github/darikoneil/CalSciPy?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/calscipy/badge/?version=latest)](https://calscipy.readthedocs.io/en/latest/?badge=latest)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/CalSciPy?)
  ![PyPI - Status](https://img.shields.io/pypi/status/CalSciPy)
  ![GitHub](https://img.shields.io/github/license/darikoneil/CalSciPy)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/darikoneil/CalSciPy/calscipy_lint_test_action.yml)

  CalSciPy is a utility toolbox for calcium imaging experiments. It contains a variety of useful features, from
  interactive visualization of data to computer-generated holography for "read/write" experiments, and
  everything in-between. Essentially, it's a collection of code written for my imaging experiments that might be
  considered useful to others. I was inspired to upload my own code to solve some of the issues outlined in the [motivation](https://calscipy.readthedocs.io/en/latest/introduction__motivation.html) section of the [docs](https://calscipy.readthedocs.io/en/latest/index.html#) or at least create a neat package my friends and I could use to easily analyze data across various environments and computers.


  As of version 0.9.8, the current implementation is unstable, partially untested, partially finished, and should be considered an open alpha/beta. ***Please be patient, refactoring my code for public use is a pet-project. I have to graduate at some point and I have a newborn.***

  Until things are more stable, I'll explicitly note which subpackages are stable, have >90% test coverage, and are ready-to-use.


  * The main module is ready to use as of 0.7.5. New features will be demarcated by a label indicating the version added in the docs.

  * The organization module is untested but incorporated into the distributed pypi version
  * The bruker module is untested but incorporated into the distributed pypi version
  * The optogenetics module is untested but incorporated into the distributed pypi version


  * The interactive module is unstable but partially incorporated into the distributed pypi version
  * The optics module is unstable and not incorporated into the distributed pypi version


  Eventually I will break things up into sub-packages so you don't have to install everything together...
  `pip install CalSciPy`


  My current focus is on refactoring tools for holographic optogenetics and circumventing PrairieView's writing of data to proprietary RAW format. I also plan on
  breaking up this repo because its many of its contents are too decoupled (e.g., bruker prairieview tricks / helpers vs experiment organization)


  Save me from myself, contributions welcome :)


  Hosted at [ReadtheDocs](https://calscipy.readthedocs.io/en/latest/index.html#).
  Available locally as [HTML](https://github.com/darikoneil/CalSciPy/tree/master/docs/build/html), [LATEX](https://github.com/darikoneil/CalSciPy/tree/master/docs/build/latex) and [PDF](https://github.com/darikoneil/CalSciPy/blob/master/docs/build/pdf/calscipy.pdf).

rpm_license:
  MIT License  Copyright (c) 2023 Darik A O’Neil  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: 52786c3beb1bf20cf7845b8a5fd270f3be813cb9d9ecf760c3e713bc73d57ec7
name: python-CalibrationCurve
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A collection of functions that streamline the process of creating calibration curves using Python.
url: https://github.com/Rhys-McAlister/CalibrationCurve
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CalibrationCurve-0.0.9-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  This file will become your README and also the index of your
  documentation.



  ``` sh
  pip install CalibrationCurve
  ```


pkgId: 2d2f40194047368b2fdd3cad5b002de741c641510a54777972e505026a110c8c
name: python-Calkulate
arch: src
version: 23.6.1
epoch: 0
release: 1
summary: Calkulate: seawater total alkalinity from titration data
url: https://pypi.org/project/Calkulate/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Calkulate-23.6.1-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/mvdh7/calkulate/workflows/Tests/badge.svg)
  [![PyPI version](https://img.shields.io/pypi/v/calkulate.svg?style=popout)](https://pypi.org/project/calkulate/)
  [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.2634304-informational)](https://doi.org/10.5281/zenodo.2634304)
  [![Docs](https://readthedocs.org/projects/calkulate/badge/?version=latest&style=flat)](https://calkulate.readthedocs.io/en/latest/)
  [![Coverage](https://github.com/mvdh7/calkulate/blob/main/.misc/coverage.svg)](https://github.com/mvdh7/calkulate/blob/main/.misc/coverage.txt)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Calkulate is a Python package for finding total alkalinity from titration data using [PyCO2SYS](https://PyCO2SYS.rtfd.io).



      pip install calkulate



  If the data for each individual titration is in its own text file and you have a spreadsheet containing the metadata for each titration on separate rows — all formatted as expected — then all you need to do with Calkulate is:

  ```python
  import calkulate as calk
  data = calk.read_csv("path/to/metadata_file.csv").calkulate()
  data.alkalinity  # <== here are your alkalinity results
  ```

  For more detail, see [the online documentation](https://mvdh.xyz/calkulate/).



  Calkulate is being developed primarily by [Dr Matthew P. Humphreys](https://www.nioz.nl/en/about/organisation/staff/matthew-humphreys) at the Royal Netherlands Institute for Sea Research ([NIOZ, Texel](https://www.nioz.nl/en)).



  If you use Calkulate in your work, please cite it as:

  > Humphreys, M. P. and Matthews, R. S. (2024).  Calkulate: total alkalinity from titration data in Python.  *Zenodo.*  [doi:10.5281/zenodo.2634304](https://doi.org/10.5281/zenodo.2634304).

  Please report which version you are using.  To find this out:

  ```python
  import calkulate as calk
  calk.hello()
  ```



  Calkulate is licensed under the [GNU General Public License version 3 (GPLv3)](https://www.gnu.org/licenses/gpl-3.0.en.html).


pkgId: 047eee090ec250e2bd18aa3d28433495a1dcff8fd0b7d6610db83c8a119ac106
name: python-Calkulate
arch: src
version: 23.6.2
epoch: 0
release: 1
summary: Calkulate: seawater total alkalinity from titration data
url: https://pypi.org/project/Calkulate/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Calkulate-23.6.2-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/mvdh7/calkulate/workflows/Tests/badge.svg)
  [![PyPI version](https://img.shields.io/pypi/v/calkulate.svg?style=popout)](https://pypi.org/project/calkulate/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/calkulate.svg)](https://anaconda.org/conda-forge/calkulate)
  [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.2634304-informational)](https://doi.org/10.5281/zenodo.2634304)
  [![Docs](https://readthedocs.org/projects/calkulate/badge/?version=latest&style=flat)](https://calkulate.readthedocs.io/en/latest/)
  [![Coverage](https://github.com/mvdh7/calkulate/blob/main/.misc/coverage.svg)](https://github.com/mvdh7/calkulate/blob/main/.misc/coverage.txt)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Calkulate is a Python package for finding total alkalinity from titration data using [PyCO2SYS](https://PyCO2SYS.rtfd.io).



      pip install calkulate



  If the data for each individual titration is in its own text file and you have a spreadsheet containing the metadata for each titration on separate rows — all formatted as expected — then all you need to do with Calkulate is:

  ```python
  import calkulate as calk
  data = calk.read_csv("path/to/metadata_file.csv").calkulate()
  data.alkalinity  # <== here are your alkalinity results
  ```

  For more detail, see [the online documentation](https://mvdh.xyz/calkulate/).



  Calkulate is being developed primarily by [Dr Matthew P. Humphreys](https://www.nioz.nl/en/about/organisation/staff/matthew-humphreys) at the Royal Netherlands Institute for Sea Research ([NIOZ, Texel](https://www.nioz.nl/en)).



  If you use Calkulate in your work, please cite it as:

  > Humphreys, M. P. and Matthews, R. S. (2024).  Calkulate: total alkalinity from titration data in Python.  *Zenodo.*  [doi:10.5281/zenodo.2634304](https://doi.org/10.5281/zenodo.2634304).

  Please report which version you are using.  To find this out:

  ```python
  import calkulate as calk
  calk.hello()
  ```



  Calkulate is licensed under the [GNU General Public License version 3 (GPLv3)](https://www.gnu.org/licenses/gpl-3.0.en.html).


pkgId: 30bdd5704985e286f220e1e62b1f95e90e7db4a961db1595bc091d8764fbfa53
name: python-CallingGPT
arch: src
version: 0.0.1.0
epoch: 0
release: 1
summary: GPT's function calling feature wrapper
url: https://github.com/RockChinQ/CallingGPT
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CallingGPT-0.0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/CallingGPT.svg)](https://pypi.python.org/pypi/CallingGPT)

  GPT's Function Calling Demo, a experiment of self-hosted ChatGPT-Plugins-like platform.

  > Recommend reading: [function-calling](https://platform.openai.com/docs/guides/gpt/function-calling)



  OpenAI's GPT models provide a function calling feature, so we can easily create `ChatGPT-Plugins-like` tools. This repository is a proof-of-concept of the function calling feature.
  In this experiment, we defined the `Plugin` as `Namespace` which contains a serial of functions. While user performing a conversation, the functions in `Namespace` will be called by the API and return the result to the user.



  1. Clone this repository and install the dependencies.

      ```bash
      git clone https://github.com/RockChinQ/CallingGPT
      cd CallingGPT
      pip install -r requirements.txt
      ```

  2. Run the `main.py` to generate `config.yaml`

      ```bash
      python main.py
      ```

  3. Edit the `config.yaml` to set your API key and other settings.
  4. Run the `main.py` and pass your modules.

      ```bash
      python main.py <module0> <module1> ...
      ```



  Use the `example/greet.py`, provides a `greet` function called when user ask GPT to greet someone.

  ```bash
  python main.py example/greet.py
  ```

  Then you can talk to the bot.

  ```
  $ python main.py examples/greet.py
  Using module: examples.greet
  >>> Hello and who are you?
  <<< Hello! I am an AI assistant. How can I assist you today?
  >>> say hello to Rock
  call<examples-greet-greet>: {
    "user": "Rock"
  }
  <<< Hello, Rock! How can I assist you today?
  >>> and to Alice
  call<examples-greet-greet>: {
    "user": "Alice"
  }
  <<< Hello, Alice! How can I assist you today?
  >>>
  ```

  Type `help` to get help.
  See [wiki](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format) for the function format.



  <details>
  <summary>examples/draw_and_wrapper_md.py </summary>

  Provides a `dalle_draw` function to use DALL·E model when user ask GPT to draw something.

  ```bash
  python main.py examples/draw_and_wrapper_md.py
  ```

  ```
  $ python main.py examples/draw_and_wrapper_md.py
  Using module: examples.draw_and_wrapper_md
  >>> hello!
  <<< Hi there! How can I assist you today?
  >>> draw a sunset for me please
  call<examples-draw_and_wrapper_md-draw>: {
    "prompt": "sunset"
  }
  <<< Sure! Here's a beautiful sunset for you:

  ![Sunset](https://oaidalleapiprodscus.blob.core.windows.net/private/org-VS9HEpJba78GXVfOcmVo7qaM/user-OHa7Jo3kL4XJDg9lo7AzdWNT/img-QmDUiwp1IGFcu8pDGZh0i7r8.png)

  I hope you like it! Let me know if there's anything else I can help you with.
  >>>
  ```

  </details>



  1. Install the package

      ```bash
      pip install --upgrade CallingGPT
      ```

  2. Create your own functions in modules(these modules can also be used in the CLI mode)

      ```python
      
      def func_a(prompt: str) -> str:  # Type hint of EACH argument and return value is REQUIRED.
          """
          The description of this func a, will be provided to the api.

          Args:
              prompt(str): The prompt of the function.

          Returns:
              The result of the function.
          """
          
          
          
          return "func_a: " + prompt
      ```

      ```python
      
      def adder(a: int, b: int) -> int:
          """
          Add two numbers.

          Args:
              a: The first number.
              b: The second number.

          Returns:
              The sum of a and b.
          """
          
          return a + b
      ```

  3. Call the wrapper

      ```python
      from CallingGPT.session.session import Session
      import your_module_a, your_module_b
      import openai

      openai.api_key = 'your_openai_api_key'

      session = Session([your_module_a, your_module_b])

      for reply in session.ask("your prompt"):
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          print(reply)
      ```

      `Session` will automatically manage context for you.

  See [wiki](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format) for the function format.


pkgId: 4104c2249af0c7e3bd87a6ca3ad73a6ab591b25e7c69d6c81eb595277bce42fe
name: python-CamsMazes
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Maze Generator and Solver using DFS
url: https://github.com/CameronRolfe/MazeGenerator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CamsMazes-1.0.10-1.src.rpm
checksum_type: sha256
description:
  Maze Generator and Solver built with Python


  [CamsMazes PyPi](https://pypi.org/project/CamsMazes/)

  ```
  pip install CamsMazes
  ```


  Use Maze and MazeVisulizer to open a GUI to view maze generation
  ```python
  from CamsMazes.maze import Maze
  from CamsMazes.maze_visaulizer import MazeVisualizer




  maze = Maze(num_rows=40, num_cols=40)

  maze_2 = Maze(num_rows=60, num_cols=40, start_row=5, start_col=10, end_row=25, end_col=15)

  maze_3 = Maze(num_rows=20, num_cols=20, seed="test seed")




  maze_visualizer = Maze(maze) # Opens GUI and the maze generation can be viewed

  maze_visualizer2 = Maze(maze_2, cell_size=10) # Each cell in maze is cell_size pixels by cell_size pixels

  maze_visualizer3 = Maze(maze_3, cell_size=10, delay_ms=2) # Delay (in milliseconds) between each maze update during maze generation
  ```


  Use Maze.to_image to export maze to png
  ```python
  from CamsMazes.maze import Maze
  maze = Maze(num_rows=40, num_cols=40)
  maze.to_img(file_name="maze") # Creates maze.png
  maze.to_img(file_name="maze_solution", solution=True) # Creates maze_solution.png (Image contains solution)
  maze.to_img(file_name="maze_2", cell_size=10) # Creates maze_2.png where each cell is 10 pixels by 10 pixels
  ```


  Use Maze.to_gif to export maze generation to gif
  ```python
  from CamsMazes.maze import Maze
  maze = Maze(num_rows=40, num_cols=40)
  maze.to_gif(file_name="maze") # Creates maze.gif
  maze.to_gif(file_name="maze_2", cell_size=10) # Creates maze_2.gif where each cell is 10 pixels by 10 pixels
  ```


  Use Maze.to_txt to export maze to txt
  ```python
  from CamsMazes.maze import Maze
  maze = Maze(num_rows=40, num_cols=40)
  maze.to_txt() # Creates maze.txt
  maze.to_txt(file_name="maze_2") # file_name can be supplied (maze_2.txt is created)
  maze.to_txt(solution=True) # Populates txt with solution
  ```


  Use Maze.to_json to export maze to JSON.

  See [to_json()](docs/Maze.md#to_json) for JSON format
  ```python
  from CamsMazes.maze import Maze
  maze = Maze(num_rows=40, num_cols=40)
  json = maze.to_json()
  ```


  Use Maze.print to print maze to console
  ```python
  from CamsMazes.maze import Maze
  maze = Maze(num_rows=40, num_cols=40)
  maze.print()
  maze.print(show_solution=True) # Maze Text will include solution path
  ```


  Exhaustive documentation for Maze


  Exhaustive documentation for MazeVisualizer


pkgId: 42d517f439de759540d58b4ca1eb8ef6db26d39f757d23e5b81dcf0c84353723
name: python-Candlestick
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: A package for finding the candlestick patterns from OHLC data
url: https://pypi.org/project/Candlestick/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Candlestick-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Candlestick Analyser.

  Version - 0.0.8

  Dataframe with column names of Date, Open, High, Low, Close, Volume

  Whats New - Dark Cloud Cover, Piercing Pattern

  example:
  import Pattern

  Pattern.doji(df) :- will add column named 'Doji' in dataframe where True for detected doji and False for rest.

  Pattern.gravestone_doji(df) :- will add column named 'Gravestone' in dataframe where True for detected gravestone doji and False for rest.

  Pattern.dragonfly_doji(df) :- will add column named 'Dragonfly' in dataframe where True for detected dragonfly doji and  False for rest.

  Pattern.longleg_doji(df) :- will add column named 'LongLeg' in dataframe where True for detected longleg doji and False for rest.

  Pattern.Hammer_Hanging_Man(df) :- will add column named 'Hammer' in dataframe where True for detected Hammer or Hanging Man and False for rest.

  Pattern.Inv_Hammer(df) :- will add column named 'Inv_Hammer' in dataframe where True for detected Inverted Hammer or Shooting Star and  False for rest.

  Pattern.Spinning_Top(df) :- will add column named 'Spinning' in dataframe where True for detected spinning top and False for rest.

  Pattern.Marubozu(df) :- will add column named 'Bull_Marubozu' & 'Bear_Marubouzu' in dataframe where 'Bull_Marubouzu' True for detected Bullish Marubozu & 'Bear_Marubozu' for detected Bearish Marubozu False for rest of both column.

  Pattern.Engulf(df) :- will add column named 'BullEngulf' 'BearEngulf' in dataframe where 'BullEngulf' True for detected Bullish Engulfing & 'BearEngulf' for detected Bearish Engulfing False for rest of both column.

  Pattern.Engulfing(df) :- will add column named 'SBullEngulf' 'SBearEngulf' in dataframe where 'SBullEngulf' True for detected Bullish Engulfing & 'SBearEngulf' for detected Bearish Engulfing False for rest of both column.

  Pattern.Harami(df) :- will add column named 'BullHarami' 'BearHarami' in dataframe where 'BullHarami' True for detected Bullish Harami & 'BearHarami' for detected Bearish Harami False for rest of both column.

  Pattern.DarkCloudCover(df) :- will add column named 'DarkCloud' in dataframe where True for detected Dark Cloud Cover pattern and False for rest.

  Pattern.PiercingPattern(df) :- will add column named 'Piercing' in dataframe where True for detected Piercing Pattern and False for rest.


pkgId: aea0884632a04b177c4e153a99fe7c376ffeab4cac68ecfd41f2d1bc2ed21579
name: python-CandyTable
arch: src
version: 2.4
epoch: 0
release: 1
summary: UNKNOWN
rpm_license: GPL3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CandyTable-2.4-1.src.rpm
checksum_type: sha256
description:
  一個產生出CandyCrush初始table的小工具
  Prerequisities
  ~~~~~~~~~~~~~~
  | 本套件pythno2跟python3皆通用
  | 若不能執行麻煩回報\ ``Pull Requests``
  Installing
  ~~~~~~~~~~
  -  安裝 Install：\ ``pip install CandyTable``

url:
  https://github.com/david30907d/HomeWork/tree/master/Python-%E6%9B%BE%E5%AD%B8%E6%96%87/hw1-CandyCrush


pkgId: 07212cd3a1fe1de98a4c4b82dca007bf7f018b4af5f80fc43bd913be7843abbd
name: python-CanvasHacks
arch: src
version: 0.0.36
epoch: 0
release: 1
summary: Tools for mitigating the user-unfriendliness of canvas.
url: https://github.com/AdamSwenson/CanvasHacks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CanvasHacks-0.0.36-1.src.rpm
checksum_type: sha256
description:
  Canvas is great! Except for the ways it isn't.

  These are tools for mitigating the user-unfriendliness of canvas

  Presently a work in progress. Don't try using it, yet....


pkgId: 92f5fd57cff260e1b05b0b531fbb6c04ec24df2525ee8040cd0f62a0c9f87fd6
name: python-CaptchaCracker
arch: src
version: 0.0.7
epoch: 0
release: 1
url: https://github.com/WooilJeong/CaptchaCracker
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CaptchaCracker-0.0.7-1.src.rpm
checksum_type: sha256
summary:
  CaptchaCracker is an open source Python library that provides functions to create and apply deep learning models for Captcha Image recognition.

description:
  <div align="center">

  <b>Open source Python Deep Learning low-code library for generating captcha image recognition models</b><br>
  <b>🚀`pip install CaptchaCracker --upgrade`</b>


  [![PyPI Latest Release](https://img.shields.io/pypi/v/captchacracker.svg)](https://pypi.org/project/captchacracker/)
  ![](https://img.shields.io/badge/TensorFlow-2.5.0-red.svg)
  ![](https://img.shields.io/badge/NumPy-1.19.5-blue.svg)
  [![Downloads](https://static.pepy.tech/badge/captchacracker)](https://pepy.tech/project/captchacracker)


  [한국어 문서](https://github.com/WooilJeong/CaptchaCracker/blob/main/README-ko.md)

  <div align="left">


  <br>



  CaptchaCracker is an open source Python library that provides functions to create and apply deep learning models for Captcha Image recognition. You can create a deep learning model that recognizes numbers in the Captcha Image as shown below and outputs a string of numbers, or you can try the model yourself.




  ![png](https://github.com/WooilJeong/CaptchaCracker/raw/main/assets/example01.png)




  ```
  023062
  ```



  Integrated into [Huggingface Spaces 🤗](https://huggingface.co/spaces) using [Gradio](https://github.com/gradio-app/gradio). Try out the Web Demo: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/akhaliq/CaptchaCracker)


  <br>



  ```bash
  pip install CaptchaCracker
  ```

  <br>



  ```
  pip install numpy==1.19.5 tensorflow==2.5.0
  ```

  <br>





  Before executing model training, training data image files in which the actual value of the Captcha image is indicated in the file name should be prepared as shown below.

  - [Download Sample Dataset](https://github.com/WooilJeong/CaptchaCracker/raw/main/sample.zip)

  ![png](https://github.com/WooilJeong/CaptchaCracker/raw/main/assets/example02.png)


  ```python
  import glob
  import CaptchaCracker as cc


  train_img_path_list = glob.glob("../data/train_numbers_only/*.png")


  img_width = 200
  img_height = 50


  CM = cc.CreateModel(train_img_path_list, img_width, img_height)


  model = CM.train_model(epochs=100)


  model.save_weights("../model/weights.h5")
  ```



  ```python
  import CaptchaCracker as cc


  img_width = 200
  img_height = 50

  max_length = 6

  characters = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}


  weights_path = "../model/weights.h5"

  AM = cc.ApplyModel(weights_path, img_width, img_height, max_length, characters)


  target_img_path = "../data/target.png"


  pred = AM.predict(target_img_path)
  print(pred)
  ```


  <br>



  - https://keras.io/examples/vision/captcha_ocr/

  <br>



  <a href="https://github.com/wooiljeong/captchacracker/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=wooiljeong/captchacracker" />
  </a>

  <br>

  <div align=center>
  <!--
  [![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2FWooilJeong%2FCaptchaCracker&count_bg=%2379C83D&title_bg=%23555555&icon=github.svg&icon_color=%23FFFFFF&title=hits&edge_flat=false)](https://hits.seeyoufarm.com) -->

  </div>


pkgId: c1bc57ad35d05f5dca1697ba1cc56b502a39c2002dc484d6ef73f37912040367
name: python-CaptureMock
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: A tool for creating mocks via a capture-replay style approach
url: http://www.texttest.org/index.php?page=capturemock
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CaptureMock-2.4.1-1.src.rpm
checksum_type: sha256
description:
  CaptureMock's approach is a so-called capture-replay approach. This means that when you 'record' your mock, CaptureMock will observe the interaction between your code and the subsystem you are mocking out, and record it in a text file in its own format. When you then run your test in 'replay mode', CaptureMock can play the role of the subsystem in question and the real subsystem does not need to even be installed.

  You can then choose, each time you run your tests, whether you wish to have the real subsystems present and verify/recreate the captured mocks, or to rely on the mocks captured by a previous run. If you are running in 'replay mode' and CaptureMock does not receive the same calls as previously, it will fail the test, and suggest that you may want to recreate the mocks in record mode.


pkgId: 8d0aa9fb827614a38c871dde38246bb1c7fcc4e48bf081ecc4df01e3c95236ce
name: python-CardiacModelGenerator
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Generate 3D model from clinical cardiac imaging data
url: https://github.com/vjaniuw/CardiacModelGenerator
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CardiacModelGenerator-0.1.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 vjaniuw  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: e3d317bc0e260672e035120ea8d0be4f30d3fff3d41e7380b2579b34fbe2a258
name: python-CardiacModelGenerator
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Generate 3D model from clinical cardiac imaging data
url: https://github.com/vjaniuw/CardiacModelGenerator
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CardiacModelGenerator-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Overview

  CardiacModelGenerator.py is a Python-based application designed for viewing slice overlays, converting pixels to universal coordinates, generating point clouds, and generating/enhancing tetrahedral meshes. Specifically, this is for cardiac models and uses MRI DICOM images and nifti masks.

  Features

  Image/Mask Viewer: Allows for a user to scroll through overlays of a mask and image Point Clouds: Can generate point cloud based on user inputs Universal Coordinates: Convers Mask/Image data to universal coordinates based on Dicom metadata Mesh: Allows for tetrahedral meshes from user inputs

  Requirements

  The script requires the following Python libraries:

  wx numpy pydicom nibabel cv2 (OpenCV) random matplotlib pyvista Install dependencies using:

  pip install wxpython numpy pydicom nibabel opencv-python matplotlib pyvista How to Use

  Input Data: Prepare images in a folder (should be dicoms). Have masks as nifti.

  Run the Script: Execute the script in your Python environment: CardiacModelGenerator.py

  Interactive GUI: The script uses wx for GUI, allowing you to interactively select data and configure settings. Visualize Point Clouds: Choose from multiple colormaps and adjust parameters like point_size and tol. Functions

  generate_point_cloud Generates a 3D point cloud from input coordinates and masks.

  Parameters: coords1, coords2, coords3: Coordinate arrays. masks1, masks2, masks3: Corresponding mask arrays. whichmask: Mask value to extract (default: 1). tol: Tolerance for coordinate matching (default: 0.1). colormap_name: Colormap for visualization (default: "viridis"). point_size: Size of the points in the visualization (default: 5). Returns: A PyVista PolyData object representing the cleaned point cloud. Example Usage

  Execute GUI. The user can:

  Select Dicom Image Folder
  User selects mask for that folder
  User clicks view segmentation
  User selects generate Point Cloud
  User selects generate mesh
  User selects fix mesh
  User can look at quality by clicking mesh quality
  Developed by vinayjani. Contributions and suggestions are welcome!

  License

  This project is licensed under the MIT License. See LICENSE for details.

rpm_license:
  MIT License  Copyright (c) 2024 vjaniuw  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: 87697297d16296e5cc552cdf110aee1d142878f71d4e8016f215e7964b1c0c06
name: python-Caribe
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Caribbean English Creoles to Standard English
url: https://pypi.org/project/Caribe/
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Caribe-0.9.4-1.src.rpm
checksum_type: sha256
description:
  - ### Trinidad English Creole to English
  ```python
  import Caribe as cb
  text= "Dem men doh kno wat dey doing wid d money bai"
  output= cb.tec_translator(text)
  print(output.tec_translate()) #Output: These men do not know what they are doing with the money.
  ```
  - ### English to Trinidad English Creole
  ```python
  import Caribe as cb
  text= "Where are you going now?"
  output= cb.english_to_tec(text)
  print(output.translate()) #Output: Weh yuh going now
  ```
  - ### Guyanese English Creole to English
  ```python
  from Caribe import guyanese as gy
  text= "Me and meh kozn waan ah job"
  output= gy.gec_translator(text)
  print(output.gec_translate()) #Output: Me and my cousin want a job.
  ```
  ____
   
   > Sample 1: Checks the english creole input against existing known creole phrases before decoding the sentence into a more standardized version of English language. A corrector is used to check and fix small grammatical errors.
  ```python

  import Caribe as cb
  sentence = "Dey have dey reasons"
  standard = cb.phrase_decode(sentence)
  standard = cb.trinidad_decode(standard)
  fixed = cb.caribe_corrector(standard)
  print(fixed) #Output: They have their reasons.
  ```
  >Sample 2: Checks the trinidad english creole input against existing known phrases
  ```python

  import Caribe as cb
  sentence = "Waz de scene"
  standard = cb.phrase_decode(sentence)
  print(standard) # Outputs: How are you
  ```
  >Sample 3: Checks the sentence for any grammatical errors or incomplete words and corrects it.
  ```python

  import Caribe as cb
  sentence = "I am playin fotball outsde"
  standard = cb.caribe_corrector(sentence)
  print(standard) # Outputs: I am playing football outside
  ```
  >Sample 4: Makes parts of speech tagging on creole words.
  ```python

  import Caribe as cb
  sentence = "wat iz de time there"
  analyse = cb.nlp()
  output = analyse.caribe_pos(sentence)
  print(output) # Outputs: ["('wat', 'PRON')", "('iz', 'VERB')", "('de', 'DET')", "('time', 'NOUN')", "('there', 'ADV')"]
  ```
  >Sample 5: Remove punctuation marks.
  ```python

  import Caribe as cb
  sentence = "My aunt, Shelly is a lawyer!"
  analyse = cb.remove_signs(sentence)
  print(analyse) # Outputs: My aunt Shelly is a lawyer
  ```
  >Sample 6: Sentence Correction using T5-KES.
  ```python

  import Caribe as cb
  sentence = "Wat you doin for d the christmas"
  correction = cb.t5_kes_corrector(sentence)
  print(correction) # Output: What are you doing for christmas?
  ```
  >Sample 7: Sentence Correction using Decoder and T5-KES.
  ```python

  import Caribe as cb
  sentence = "Ah want ah phone for d christmas"
  decoded= cb.trinidad_decode(sentence)
  correction = cb.t5_kes_corrector(decoded)
  print(correction) # Output: I want a phone for christmas.
  ```
  >Sample 8: Sentence Capitalisation.
  ```python

  import Caribe as cb
  sentence = "john is a boy. he is 12 years old. his sister's name is Joy."
  capitalized_text= cb.capitalize(sentence)
  print(capitalized_text) # Output: John is a boy. He is 12 years old. His sister's name is Joy.


pkgId: 3382c3ba18b5e106af913376d36ba19775336c4d0e3659f498e4f758eaae21c5
name: python-Carousel
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Model Simulation Framework
url: https://github.com/SunPower/Carousel
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Carousel-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Carousel ia a framework for simulating mathematical models that decouples
  the models from the simulation implementation. It takes care of boilerplate
  routines such as loading data from various sources into a key store that can be
  used from any calculation, determining the correct order of calculations,
  stepping through dynamic simulations and generating output reports and
  visualizations, so that you can focus on developing models and don't have to
  worry about how to add new models or how to integrate changes.


pkgId: f877472380d068a31403527ede11cdec9619f2f66ee05a61e16f4d836685da82
name: python-CaseRecommender
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A recommender systems framework for Python
url: https://github.com/caserec/CaseRecommender
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CaseRecommender-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Case Recommender is a Python implementation of a number of popular recommendation algorithms for both implicit and
  explicit feedback.  The framework aims to provide a rich set of components from which you can construct a customized
  recommender system from a set of algorithms. Case Recommender has different types of item recommendation and rating
  prediction approaches, and different metrics validation and evaluation.
  Algorithms
  ^^^^^^^^^^^^
  Item Recommendation:
  - BPRMF
  - ItemKNN
  - Item Attribute KNN
  - UserKNN
  - User Attribute KNN
  - Group-based (Clustering-based algorithm)
  - Paco Recommender (Co-Clustering-based algorithm)
  - Most Popular
  - Random
  - Content Based
  Rating Prediction:
  - Matrix Factorization (with and without baseline)
  - SVD
  - Non-negative Matrix Factorization
  - SVD++
  - ItemKNN
  - Item Attribute KNN
  - UserKNN
  - User Attribute KNN
  - Item NSVD1 (with and without Batch)
  - User NSVD1 (with and without Batch)
  - Most Popular
  - Random
  - gSVD++
  - Item-MSMF
  - (E)CoRec
  Clustering:
  - PaCo: EntroPy Anomalies in Co-Clustering
  - k-medoids
  Evaluation and Validation Metrics
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  - All-but-one Protocol
  - Cross-fold- Validation
  - Item Recommendation: Precision, Recall, NDCG and Map
  - Rating Prediction: MAE and RMSE
  - Statistical Analysis (T-test and Wilcoxon)
  Requirements
  ^^^^^^^^^^^^^
  - Python >= 3
  - scipy
  - numpy
  - pandas
  - scikit-learn
  For Linux, Windows and MAC use:
      $ pip install requirements
  For Windows libraries help use:
      http://www.lfd.uci.edu/~gohlke/pythonlibs/
  Quick Start and Guide
  ^^^^^^^^^^^^^^^^^^^^^^
  For more information about RiVal and the documentation,
  visit the Case Recommender
  `Wiki <https://github.com/caserec/CaseRecommender/wiki>`_. If you have not used Case Recommender before, do check out the Getting Started guide.
  Installation
  ^^^^^^^^^^^^^
  Case Recommender can be installed using pip:
      $ pip install caserecommender
  If you want to run the latest version of the code, you can install from git:
      $ pip install -U git+git://github.com/caserec/CaseRecommender.git
  More Details
  ^^^^^^^^^^^^^
      `https://github.com/caserec/CaseRecommender <https://github.com/caserec/CaseRecommender>`_
  License (MIT)
  ^^^^^^^^^^^^^^
      © 2019. Case Recommender All Rights Reserved
      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: 1a52c178905f94bc22cfe877f472eda06d6072e265d3e5288dcf8b113f36bf3f
name: python-CassavaPy
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: A package to write, run and get outputs from DSSAT-Manihot model
url: https://github.com/FabioSeixas/CassavaPy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CassavaPy-0.0.13-1.src.rpm
checksum_type: sha256
description:
  Apart from get hands dirty with OOP, the aim of this module is to make my life easier during my master degree.


pkgId: 4602b424ea238535e1ae41f7a63d716169f53d9a563591e4166626067f76bd92
name: python-CausalEGM
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/SUwonglab/CausalEGM
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CausalEGM-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  CausalEGM: an encoding generative modeling approach to dimension reduction and covariate adjustment in causal inference with observational studies

description:
  In this article, we develop CausalEGM, a deep learning framework for nonlinear dimension reduction and generative modeling of the dependency among covariate features affecting treatment and response. CausalEGM can be used for estimating causal effects in both binary and continuous treatment settings. By learning a bidirectional transformation between the high-dimensional covariate space and a low-dimensional latent space and then modeling the dependencies of different subsets of the latent variables on the treatment and response, CausalEGM can extract the latent covariate features that affect both treatment and response. By conditioning on these features, one can mitigate the confounding effect of the high dimensional covariate on the estimation of the causal relation between treatment and response. In a series of experiments, the proposed method is shown to achieve superior performance over existing methods in both binary and continuous treatment settings. The improvement is substantial when the sample size is large and the covariate is of high dimension. Finally, we established excess risk bounds and consistency results for our method, and discuss how our approach is related to and improves upon other dimension reduction approaches in causal inference. CausalEGM is freely available at https://github.com/SUwonglab/CausalEGM.


pkgId: 2937f83625f3990dbb9336fe71cb3fbd60435bb73d7e62b0b0a562cc586b7bdc
name: python-CausalInference
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Causal Inference in Python
url: https://github.com/laurencium/causalinference
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CausalInference-0.1.3-1.src.rpm
checksum_type: sha256
description:
  *Causal Inference in Python*, or *Causalinference* in short, is a software package that implements various statistical and econometric methods used in the field variously known as Causal Inference, Program Evaluation, or Treatment Effect Analysis.
  Work on *Causalinference* started in 2014 by Laurence Wong as a personal side project. It is distributed under the 3-Clause BSD license.


pkgId: de148dc76584ccb6d02a9f2a64793930f6720c22ac75a6026f5dfec31bb65ad9
name: python-CausalPy
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Causal inference for quasi-experiments in Python
url: https://github.com/pymc-labs/CausalPy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CausalPy-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/pymc-labs/CausalPy/workflows/ci/badge.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)]([https://codecov.io/gh/pymc-labs/CausalPy](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json))
  [![PyPI version](https://badge.fury.io/py/CausalPy.svg)](https://badge.fury.io/py/CausalPy)
  ![GitHub Repo stars](https://img.shields.io/github/stars/pymc-labs/causalpy?style=social)
  ![Read the Docs](https://img.shields.io/readthedocs/causalpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/causalpy)
  ![Interrogate](docs/source/_static/interrogate_badge.svg)
  [![codecov](https://codecov.io/gh/pymc-labs/CausalPy/branch/main/graph/badge.svg?token=FDKNAY5CZ9)](https://codecov.io/gh/pymc-labs/CausalPy)

  A Python package focussing on causal inference in quasi-experimental settings. The package allows for sophisticated Bayesian model fitting methods to be used in addition to traditional OLS.

  To get the latest release:
  ```bash
  pip install CausalPy
  ```
  Alternatively, if you want the very latest version of the package you can install from GitHub:
  ```bash
  pip install git+https://github.com/pymc-labs/CausalPy.git
  ```

  ```python
  import causalpy as cp
  import matplotlib.pyplot as plt

  df = (
      cp.load_data("drinking")
      .rename(columns={"agecell": "age"})
      .assign(treated=lambda df_: df_.age > 21)
      )

  result = cp.RegressionDiscontinuity(
      df,
      formula="all ~ 1 + age + treated",
      running_variable_name="age",
      model=cp.pymc_models.LinearRegression(),
      treatment_threshold=21,
      )

  fig, ax = result.plot();

  result.summary()
  plt.show()
  ```

  Plans for the repository can be seen in the [Issues](https://github.com/pymc-labs/CausalPy/issues).

  Click on the thumbnail below to watch a video about CausalPy on YouTube.
  [![Youtube video thumbnail image](https://img.youtube.com/vi/gV6wzTk3o1U/maxresdefault.jpg)](https://www.youtube.com/watch?v=gV6wzTk3o1U)


  This is appropriate when you have multiple units, one of which is treated. You build a synthetic control as a weighted combination of the untreated units.
  | Time | Outcome   | Control 1 | Control 2 | Control 3 |
  |------|-----------|-----------|-----------|-----------|
  | 0    | $y_0$ | $x_{1,0}$ | $x_{2,0}$ | $x_{3,0}$ |
  | 1    | $y_1$ | $x_{1,1}$ | $x_{2,1}$ | $x_{3,1}$ |
  |$\ldots$ | $\ldots$  | $\ldots$  | $\ldots$  | $\ldots$  |
  | T    | $y_T$ | $x_{1,T}$ | $x_{2,T}$ | $x_{3,T}$ |
  | Frequentist | Bayesian |
  |--|--|
  | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/synthetic_control_skl.svg) | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/synthetic_control_pymc.svg) |
  > The data (treated and untreated units), pre-treatment model fit, and counterfactual (i.e. the synthetic control) are plotted (top). The causal impact is shown as a blue shaded region. The Bayesian analysis shows shaded Bayesian credible regions of the model fit and counterfactual. Also shown is the causal impact (middle) and cumulative causal impact (bottom).

  We can also use synthetic control methods to analyse data from geographical lift studies. For example, we can try to evaluate the causal impact of an intervention (e.g. a marketing campaign) run in one geographical area by using control geographical areas which are similar to the intervention area but which did not recieve the specific marketing intervention.

  This is appropriate for non-equivalent group designs when you have a single pre and post intervention measurement and have a treament and a control group.
  | Group | pre | post |
  |------|---|-------|
  | 0    | $x_1$ | $y_1$ |
  | 0    | $x_2$ | $y_2$ |
  | 1    | $x_3$ | $y_3$ |
  | 1    | $x_4$ | $y_4$ |
  | Frequentist | Bayesian |
  |--|--|
  | coming soon | ![](docs/source/_static/anova_pymc.svg) |
  > The data from the control and treatment group are plotted, along with posterior predictive 94% credible intervals. The lower panel shows the estimated treatment effect.

  This is appropriate for non-equivalent group designs when you have pre and post intervention measurement and have a treament and a control group. Unlike the ANCOVA approach, difference in differences is appropriate when there are multiple pre and/or post treatment measurements.
  Data is expected to be in the following form. Shown are just two units - one in the treated group (`group=1`) and one in the untreated group (`group=0`), but there can of course be multiple units per group. This is panel data (also known as repeated measures) where each unit is measured at 2 time points.
  | Unit | Time | Group | Outcome         |
  |------|---|-------|-----------|
  | 0    | 0 | 0     | $y_{0,0}$ |
  | 0    | 1 | 0     | $y_{0,0}$ |
  | 1    | 0 | 1     | $y_{1,0}$ |
  | 1    | 1 | 1     | $y_{1,1}$ |
  | Frequentist | Bayesian |
  |--|--|
  | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/difference_in_differences_skl.svg) | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/difference_in_differences_pymc.svg) |
  >The data, model fit, and counterfactual are plotted. Frequentist model fits result in points estimates, but the Bayesian analysis results in posterior distributions, represented by the violin plots. The causal impact is the difference between the counterfactual prediction (treated group, post treatment) and the observed values for the treated group, post treatment.

  Regression discontinuity designs are used when treatment is applied to units according to a cutoff on the running variable (e.g. $x$) which is typically _not_ time. By looking for the presence of a discontinuity at the precise point of the treatment cutoff then we can make causal claims about the potential impact of the treatment.
  | Running variable | Outcome | Treated  |
  |-----------|-----------|----------|
  | $x_0$     | $y_0$     | False    |
  | $x_1$     | $y_0$     | False    |
  | $\ldots$  | $\ldots$  | $\ldots$ |
  | $x_{N-1}$ | $y_{N-1}$ | True     |
  | $x_N$     | $y_N$     | True     |
  | Frequentist | Bayesian |
  |--|--|
  | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/regression_discontinuity_skl.svg) | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/regression_discontinuity_pymc.svg) |
  > The data, model fit, and counterfactual are plotted (top). Frequentist analysis shows the causal impact with the blue shaded region, but this is not shown in the Bayesian analysis to avoid a cluttered chart. Instead, the Bayesian analysis shows shaded Bayesian credible regions of the model fits. The Frequentist analysis visualises the point estimate of the causal impact, but the Bayesian analysis also plots the posterior distribution of the regression discontinuity effect (bottom).

  Regression discontinuity designs are used when treatment is applied to units according to a cutoff on a running variable, which is typically not time. By looking for the presence of a discontinuity at the precise point of the treatment cutoff then we can make causal claims about the potential impact of the treatment.
  | Running variable | Outcome |
  |-----------|-----------|
  | $x_0$     | $y_0$     |
  | $x_1$     | $y_0$     |
  | $\ldots$  | $\ldots$  |
  | $x_{N-1}$ | $y_{N-1}$ |
  | $x_N$     | $y_N$     |
  | Frequentist | Bayesian |
  |--|--|
  | coming soon | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/regression_kink_pymc.svg) |
  > The data and model fit. The Bayesian analysis shows the posterior mean with credible intervals (shaded regions). We also report the Bayesian $R^2$ on the data along with the posterior mean and credible intervals of the change in gradient at the kink point.

  Interrupted time series analysis is appropriate when you have a time series of observations which undergo treatment at a particular point in time. This kind of analysis has no control group and looks for the presence of a change in the outcome measure at or soon after the treatment time. Multiple predictors can be included.
  | Time | Outcome | Treated  | Predictor |
  |-----------|-----------|----------|----------|
  | $t_0$     | $y_0$     | False    | $x_0$     |
  | $t_1$     | $y_0$     | False    | $x_1$     |
  | $\ldots$  | $\ldots$  | $\ldots$ | $\ldots$  |
  | $t_{N-1}$ | $y_{N-1}$ | True     | $x_{N-1}$ |
  | $t_N$     | $y_N$     | True     | $x_N$     |
  | Frequentist | Bayesian |
  |--|--|
  | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/interrupted_time_series_skl.svg) | ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/interrupted_time_series_pymc.svg) |
  > The data, pre-treatment model fit, and counterfactual are plotted (top). The causal impact is shown as a blue shaded region. The Bayesian analysis shows shaded Bayesian credible regions of the model fit and counterfactual. Also shown is the causal impact (middle) and cumulative causal impact (bottom).

  Instrumental Variable regression is an appropriate technique when you wish to estimate the treatment effect of some variable on another, but are concerned that the treatment variable is endogenous in the system of interest i.e. correlated with the errors. In this case an “instrument” variable can be used in a regression context to disentangle treatment effect due to the threat of confounding due to endogeneity.
  ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/iv_reg1.png)

  Propensity scores are often used to address the risks of bias or confounding introduced in an observational study by
  selection effects into the treatment condition. Propensity scores can be used in a number of ways, but here we demonstrate
  their usage within corrective weighting schemes aimed to recover as-if random allocation of subjects to the treatment condition.
  The technique "up-weights" or "down-weights" individual observations to better estimate a causal estimand such as the average treatment
  effect.
  ![](https://raw.githubusercontent.com/pymc-labs/CausalPy/main/docs/source/_static/propensity_weight.png)

  Here are some general resources about causal inference:
  * The official [PyMC examples gallery](https://www.pymc.io/projects/examples/en/latest/gallery.html) has a set of examples specifically relating to causal inference.
  * Angrist, J. D., & Pischke, J. S. (2009). Mostly harmless econometrics: An empiricist's companion. Princeton university press.
  * Angrist, J. D., & Pischke, J. S. (2014). Mastering'metrics: The path from cause to effect. Princeton university press.
  * Cunningham, S. (2021). [Causal inference: The Mixtape](https://mixtape.scunning.com). Yale University Press.
  * Huntington-Klein, N. (2021). [The effect: An introduction to research design and causality](https://theeffectbook.net). Chapman and Hall/CRC.
  * Reichardt, C. S. (2019). Quasi-experimentation: A guide to design and analysis. Guilford Publications.

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: ecf83b2c3a127c0525630055ab1333d180162d45313e782bfe885f46bad503f0
name: python-Celery-OpenTracing
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: OpenTracing support for Celery
url: http://github.com/signalfx/python-celery
rpm_license: Apache Software License v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Celery-OpenTracing-0.0.1-1.src.rpm
checksum_type: sha256
description:
  This package enables tracing task execution in a [Celery 3.1+](http://www.celeryproject.org/) application via [The OpenTracing Project](http://opentracing.io). Once a production system contends with real concurrency or splits into many services, crucial (and formerly easy) tasks become difficult: user-facing latency optimization, root-cause analysis of backend errors, communication about distinct pieces of a now-distributed system, etc. Distributed tracing follows a request on its journey from inception to completion from mobile/browser all the way to the microservices.

  As core services and libraries adopt OpenTracing, the application builder is no longer burdened with the task of adding basic tracing instrumentation to their own code. In this way, developers can build their applications with the tools they prefer and benefit from built-in tracing instrumentation. OpenTracing implementations exist for major distributed tracing systems and can be bound or swapped with a one-line configuration change.

  If you want to learn more about the underlying Python API, visit the Python [source code](https://github.com/signalfx/python-celery/).



  Run the following command:

  ```
  $ pip install celery-opentracing
  ```



  The provided `celery.app.base.Celery` subclass allows the tracing of task scheduling and execution using the OpenTracing API. All that it requires is for a `CeleryTracing` instance to be initialized using an instance of an OpenTracing tracer and treated as a standard `Celery` application.



  `CeleryTracing` takes the `Tracer` instance that is supported by OpenTracing and an optional dictionary of desired tags for each created span. You can also specify whether you'd like the initial task publish events to be represented by a span whose trace context is propagated via request headers to the worker executing the task (enabled by default).  To create a `CeleryTracing` object, you can either pass in a tracer object directly or default to the `opentracing.tracer` global tracer that's set elsewhere in your application:

  ```python
  from celery_opentracing import CeleryTracing

  opentracing_tracer = # some OpenTracing tracer implementation
  traced_app = CeleryTracing(tracer=opentracing_tracer, propagate=True,  # propagation allows distributed tracing from
                             span_tags=dict(my_helpful='tag'))           # publisher over broker to workers.

  @traced_app.task(bind=True)
  def my_task(self):
      return True
  ```

  or

  ```python
  from celery_opentracing import CeleryTracing
  import opentracing

  opentracing.tracer = # some OpenTracing tracer implementation
  traced_app = CeleryTracing(propagate=False)  # Tracer defaults to opentracing.tracer.  No publish span creation or propagation to worker execution context will configured as well.

  @traced_app.task(bind=True)
  def my_task(self):
      return True
  ```



  If you're interested in learning more about the OpenTracing standard, please visit [opentracing.io](http://opentracing.io/).  If you would like to implement OpenTracing in your project and need help, feel free to send us a note at [community@opentracing.io](community@opentracing.io).


pkgId: ef1e86bf87a6f07033efdb8c0bcab26b74fbc32c241c02f862cbcfd741b3b449
name: python-Cell-BLAST
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Single-cell transcriptome querying tool
url: https://pypi.org/project/Cell-BLAST/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cell-BLAST-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![license-badge](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![pypi-badge](https://img.shields.io/pypi/v/Cell-BLAST)](https://pypi.org/project/Cell-BLAST)
  [![docs-badge](https://readthedocs.org/projects/cblast/badge/?version=latest)](https://cblast.readthedocs.io/en/latest/?badge=latest)
  [![build-badge](https://github.com/gao-lab/Cell_BLAST/actions/workflows/build.yml/badge.svg)](https://github.com/gao-lab/Cell_BLAST/actions/workflows/build.yml)

  Cell BLAST is a cell querying tool for single-cell transcriptomics data.

  For each query cell, it searches for most similar cells in the reference database.
  Annotations in reference cells, e.g. cell type, can then be transfered to query
  cells based on cell-to-cell similarities. See our
  [publication](https://www.nature.com/articles/s41467-020-17281-7) for details.



  We only support installation via pip right now.

  Installation within virtual environments are recommended, see
  [virtualenv](https://virtualenv.pypa.io/en/latest/) or
  [conda](https://conda.io/docs/user-guide/tasks/manage-environments.html).

  For conda, here's a one-liner to set up an empty environment
  for installing Cell BLAST:

  `conda create -n cb python=3.9 && conda activate cb`

  Then follow the instructions below to install Cell BLAST:

  1. Install Cell BLAST from PyPI by running:

     `pip install Cell-BLAST`

     Or, install an editable dev version by running the following command
     under the root directory of this repo:

     `flit install -s`

  2. Check if the package can be imported in the Python interpreter:

     ```python
     import Cell_BLAST as cb
     print(cb.__version__)
     ```



  Online documentation can be found [here](https://cblast.readthedocs.org/).



  We also provide a [Web-based service](http://cblast.gao-lab.org/) for
  off-the-shelf querying of our ACA reference panels.



  To reproduce results, please check out the `rep` branch.



  Feel free to submit an issue or contact us at
  [cblast@mail.cbi.pku.edu.cn](mailto:cblast@mail.cbi.pku.edu.cn)
  for problems about the Python package, website or database.


pkgId: 90ce3556dce9c2d94d494e62ed1a928a9025b7277c1847975a86817e7ebbdd3d
name: python-CellCover
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: CellCover
url: https://pypi.org/project/CellCover/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CellCover-0.1.9-1.src.rpm
checksum_type: sha256
description:
  This is the python version of CellCover. To run CellCover, Gurobi installation is necessary. Please follow the README.md in [lanlanji/CoveringPackage (github.com)](https://github.com/lanlanji/CoveringPackage) to acquire and install the Gurobi academic liscence.



  ```python
  pip install CellCover
  ```



  To run the CelCover, the following python variables need to be define first:

  - **data**: a numpy array of your single cell RNA-seq data with shape (N,G) where N is the number of cells and G is the size of the gene portfolio.

  - **gene**: a numpy array of gene names with shape (G,)

  - **CellTypeLabels**: a numpy array of cell types with shape (N,)

  - **CellTypeNames**: a numpy array of distinct cell type names (string)

  - **ct**: a single string of the cell type name that user want to find covering markers for, e.g. "CD4"

  What is more, there is a list of hyperparameters that need to be defined before running the covering:

  - **binarization_threshold**: the threshold above which we binarize the gene expression to 1, below which we binarize the gene expression to 0

  - **minSize**: the depth of covering

  - **alpha**: 1 - covering rate. The default is $0.05$

  - **te**: This is a parameter for pruning the data. For each cell type, the gene expressing more than te * 100 percent of time are selected for finding the covering markers. The default is $0.1$.

  - **top_num_gene**: This is another pruning parameter. In each class, **top_num_gene** number of genes with the highest margin score will be selected for marker selection. The default is $6000$.

  The pipeline of getting the covering marker panel of the user defined cell type **ct** is

  ```python
  from CellCover import binarization
  from CellCover import SensList
  from CellCover import weight
  from CellCover import covering
  from CellCover import getCoveringVariables
  data = binarization(mat = data, binarization_threshold =  binarization_threshold)
  sens = SensList(mat = data, CellTypeLabels =  CellTypeLabels, CellTypeNames=CellTypeNames)
  X,w,g = weight(mat = data,sens =sens, CellTypeLabels = CellTypeLabels, CellTypeNames = CellTypeNames, ct = ct,gene = gene)
  cov = covering(Z=X, minSize = minSize, alpha = alpha,weights = w)
  marker = getCoveringVariables(cov, ngenes = len(g), geneNames = g, nlevels = 1)

  ```


pkgId: a22b5279492f3a7017e3d071a3266bc80a9eaaa40713cdda05852921e0f98b27
name: python-CellDetection
arch: src
version: 0.4.9
epoch: 0
release: 1
summary: Cell Detection with PyTorch.
url: https://celldetection.org
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CellDetection-0.4.9-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/celldetection?l)](https://pepy.tech/project/celldetection)
  [![Test](https://github.com/FZJ-INM1-BDA/celldetection/workflows/Test/badge.svg)](https://github.com/FZJ-INM1-BDA/celldetection/actions?query=workflow%3ATest)
  [![PyPI](https://img.shields.io/pypi/v/celldetection?l)](https://pypi.org/project/celldetection/)
  [![Documentation Status](https://readthedocs.org/projects/celldetection/badge/?version=latest)](https://celldetection.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/349111085.svg)](https://zenodo.org/badge/latestdoi/349111085)





  ![neurips22](https://raw.githubusercontent.com/FZJ-INM1-BDA/celldetection/main/assets/neurips-cellseg-demo.png "NeurIPS 22 Cell Segmentation Competition - Find more information here: https://neurips.cc/Conferences/2022/CompetitionTrack")
  *https://openreview.net/forum?id=YtgRjBw-7GJ*



  ![bbbc039](https://raw.githubusercontent.com/FZJ-INM1-BDA/celldetection/main/assets/bbbc039-cpn-u22-demo.png "BBBC039 demo with CpnU22 - Find the dataset here: https://bbbc.broadinstitute.org/BBBC039")
  *https://bbbc.broadinstitute.org/BBBC039 (CC0)*



  ![bbbc041](https://raw.githubusercontent.com/FZJ-INM1-BDA/celldetection/main/assets/bbbc041-cpn-u22-demo.png "BBBC041 demo with CpnU22 - Find the dataset here: https://bbbc.broadinstitute.org/BBBC041")
  *https://bbbc.broadinstitute.org/BBBC041 (CC BY-NC-SA 3.0)*



  Make sure you have [PyTorch](https://pytorch.org/get-started/locally/) installed.



  ```
  pip install -U celldetection
  ```



  ```
  pip install git+https://github.com/FZJ-INM1-BDA/celldetection.git
  ```



  ```python
  model = cd.fetch_model(model_name, check_hash=True)
  ```

  | model name                                  | training data                                                                                                        |                                           link                                            |
  |---------------------------------------------|----------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------:|
  | `ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c` | BBBC039, BBBC038, Omnipose, Cellpose, Sartorius - Cell Instance Segmentation, Livecell, NeurIPS 22 CellSeg Challenge | [🔗](https://celldetection.org/torch/models/ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c.pt) |

  <details>
    <summary style="font-weight: bold; color: #888888">Run a demo with a pretrained model</summary>

  ```python
  import torch, cv2, celldetection as cd
  from skimage.data import coins
  from matplotlib import pyplot as plt


  device = 'cuda' if torch.cuda.is_available() else 'cpu'
  model = cd.fetch_model('ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c', check_hash=True).to(device)
  model.eval()


  img = coins()
  img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
  print(img.dtype, img.shape, (img.min(), img.max()))


  with torch.no_grad():
      x = cd.to_tensor(img, transpose=True, device=device, dtype=torch.float32)
      x = x / 255  # ensure 0..1 range
      x = x[None]  # add batch dimension: Tensor[3, h, w] -> Tensor[1, 3, h, w]
      y = model(x)


  contours = y['contours']
  for n in range(len(x)):
      cd.imshow_row(x[n], x[n], figsize=(16, 9), titles=('input', 'contours'))
      cd.plot_contours(contours[n])
      plt.show()
  ```

  </details>



  ```python
  import celldetection as cd
  ```

  <details>
    <summary style="font-weight: bold; color: #888888">Contour Proposal Networks</summary>

  - [`cd.models.CPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CPN)
  - [`cd.models.CpnU22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnU22)
  - [`cd.models.CPNCore`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CPNCore)
  - [`cd.models.CpnResUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResUNet)
  - [`cd.models.CpnSlimU22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnSlimU22)
  - [`cd.models.CpnWideU22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnWideU22)
  - [`cd.models.CpnResNet18FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet18FPN)
  - [`cd.models.CpnResNet34FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet34FPN)
  - [`cd.models.CpnResNet50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet50FPN)
  - [`cd.models.CpnResNeXt50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt50FPN)
  - [`cd.models.CpnResNet101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet101FPN)
  - [`cd.models.CpnResNet152FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet152FPN)
  - [`cd.models.CpnResNet18UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet18UNet)
  - [`cd.models.CpnResNet34UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet34UNet)
  - [`cd.models.CpnResNet50UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet50UNet)
  - [`cd.models.CpnResNeXt101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt101FPN)
  - [`cd.models.CpnResNeXt152FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt152FPN)
  - [`cd.models.CpnResNeXt50UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt50UNet)
  - [`cd.models.CpnResNet101UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet101UNet)
  - [`cd.models.CpnResNet152UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNet152UNet)
  - [`cd.models.CpnResNeXt101UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt101UNet)
  - [`cd.models.CpnResNeXt152UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnResNeXt152UNet)
  - [`cd.models.CpnWideResNet50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnWideResNet50FPN)
  - [`cd.models.CpnWideResNet101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnWideResNet101FPN)
  - [`cd.models.CpnMobileNetV3LargeFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnMobileNetV3LargeFPN)
  - [`cd.models.CpnMobileNetV3SmallFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnMobileNetV3SmallFPN)

  </details>

  <details>
    <summary style="font-weight: bold; color: #888888">PyTorch Image Models (timm)</summary>

  Also have a look at [Timm Documentation](https://huggingface.co/docs/timm/index).

  ```python
  import timm

  timm.list_models(filter='*')  # explore available models
  ```

  - [`cd.models.CpnTimmMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnTimmMaNet)
  - [`cd.models.CpnTimmUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnTimmUNet)
  - [`cd.models.TimmEncoder`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.timmodels.TimmEncoder)
  - [`cd.models.TimmFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.TimmFPN)
  - [`cd.models.TimmMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.manet.TimmMaNet)
  - [`cd.models.TimmUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.TimmUNet)

  </details>

  <details>
    <summary style="font-weight: bold; color: #888888">Segmentation Models PyTorch (smp)</summary>

  ```python
  import segmentation_models_pytorch as smp

  smp.encoders.get_encoder_names()  # explore available models
  ```

  ```python
  encoder = cd.models.SmpEncoder(encoder_name='mit_b5', pretrained='imagenet')
  ```

  Find a list of [Smp Encoders](https://smp.readthedocs.io/en/latest/encoders.html) in the `smp` documentation.

  - [`cd.models.CpnSmpMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnSmpMaNet)
  - [`cd.models.CpnSmpUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.cpn.CpnSmpUNet)
  - [`cd.models.SmpEncoder`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.smp.SmpEncoder)
  - [`cd.models.SmpFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.SmpFPN)
  - [`cd.models.SmpMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.manet.SmpMaNet)
  - [`cd.models.SmpUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.SmpUNet)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">U-Nets</summary>

  ```python

  import celldetection as cd

  model = cd.models.ResNeXt50UNet(in_channels=3, out_channels=1, nd=3)
  ```

  - [`cd.models.U22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.U22)
  - [`cd.models.U17`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.U17)
  - [`cd.models.U12`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.U12)
  - [`cd.models.UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.UNet)
  - [`cd.models.WideU22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.WideU22)
  - [`cd.models.SlimU22`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.SlimU22)
  - [`cd.models.ResUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResUNet)
  - [`cd.models.UNetEncoder`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.UNetEncoder)
  - [`cd.models.ResNet50UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNet50UNet)
  - [`cd.models.ResNet18UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNet18UNet)
  - [`cd.models.ResNet34UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNet34UNet)
  - [`cd.models.ResNet152UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNet152UNet)
  - [`cd.models.ResNet101UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNet101UNet)
  - [`cd.models.ResNeXt50UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNeXt50UNet)
  - [`cd.models.ResNeXt152UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNeXt152UNet)
  - [`cd.models.ResNeXt101UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.ResNeXt101UNet)
  - [`cd.models.WideResNet50UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.WideResNet50UNet)
  - [`cd.models.WideResNet101UNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.WideResNet101UNet)
  - [`cd.models.MobileNetV3SmallUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.MobileNetV3SmallUNet)
  - [`cd.models.MobileNetV3LargeUNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.unet.MobileNetV3LargeUNet)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">MA-Nets</summary>

  ```python

  import celldetection as cd

  encoder = cd.models.ConvNeXtSmall(in_channels=3, nd=3)
  model = cd.models.MaNet(encoder, out_channels=1, nd=3)
  ```

  - [`cd.models.MaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.manet.MaNet)
  - [`cd.models.SmpMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.manet.SmpMaNet)
  - [`cd.models.TimmMaNet`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.manet.TimmMaNet)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">Feature Pyramid Networks</summary>

  - [`cd.models.FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.FPN)
  - [`cd.models.ResNet18FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNet18FPN)
  - [`cd.models.ResNet34FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNet34FPN)
  - [`cd.models.ResNet50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNet50FPN)
  - [`cd.models.ResNeXt50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNeXt50FPN)
  - [`cd.models.ResNet101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNet101FPN)
  - [`cd.models.ResNet152FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNet152FPN)
  - [`cd.models.ResNeXt101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNeXt101FPN)
  - [`cd.models.ResNeXt152FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.ResNeXt152FPN)
  - [`cd.models.WideResNet50FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.WideResNet50FPN)
  - [`cd.models.WideResNet101FPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.WideResNet101FPN)
  - [`cd.models.MobileNetV3LargeFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.MobileNetV3LargeFPN)
  - [`cd.models.MobileNetV3SmallFPN`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.fpn.MobileNetV3SmallFPN)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">ConvNeXt Networks</summary>

  ```python

  import celldetection as cd

  model = cd.models.ConvNeXtSmall(in_channels=3, nd=3)
  ```

  - [`cd.models.ConvNeXt`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.convnext.MaNet)
  - [`cd.models.ConvNeXtTiny`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.convnext.ConvNeXtTiny)
  - [`cd.models.ConvNeXtSmall`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.convnext.ConvNeXtSmall)
  - [`cd.models.ConvNeXtBase`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.convnext.ConvNeXtBase)
  - [`cd.models.ConvNeXtLarge`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.convnext.ConvNeXtLarge)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">Residual Networks</summary>

  ```python

  import celldetection as cd

  model = cd.models.ResNet50(in_channels=3, nd=3)
  ```

  - [`cd.models.ResNet18`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNet18)
  - [`cd.models.ResNet34`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNet34)
  - [`cd.models.ResNet50`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNet50)
  - [`cd.models.ResNet101`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNet101)
  - [`cd.models.ResNet152`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNet152)
  - [`cd.models.WideResNet50_2`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.WideResNet50_2)
  - [`cd.models.ResNeXt50_32x4d`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNeXt50_32x4d)
  - [`cd.models.WideResNet101_2`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.WideResNet101_2)
  - [`cd.models.ResNeXt101_32x8d`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNeXt101_32x8d)
  - [`cd.models.ResNeXt152_32x8d`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.resnet.ResNeXt152_32x8d)

  </details>

  <details>
      <summary style="font-weight: bold; color: #888888">Mobile Networks</summary>

  - [`cd.models.MobileNetV3Large`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.mobilenetv3.MobileNetV3Large)
  - [`cd.models.MobileNetV3Small`](https://docs.celldetection.org/en/latest/celldetection.models.html#celldetection.models.mobilenetv3.MobileNetV3Small)

  </details>



  Find us on Docker Hub: https://hub.docker.com/r/ericup/celldetection

  You can pull the latest version of `celldetection` via:
  ```
  docker pull ericup/celldetection:latest
  ```

  <details>
      <summary style="font-weight: bold; color: #888888">CPN inference via Docker with GPU</summary>

  ```
  docker run --rm \
    -v $PWD/docker/outputs:/outputs/ \
    -v $PWD/docker/inputs/:/inputs/ \
    -v $PWD/docker/models/:/models/ \
    --gpus="device=0" \
    celldetection:latest /bin/bash -c \
    "python cpn_inference.py --tile_size=1024 --stride=768 --precision=32-true"
  ```
  </details>
  <details>
      <summary style="font-weight: bold; color: #888888">CPN inference via Docker with CPU</summary>

  ```
  docker run --rm \
    -v $PWD/docker/outputs:/outputs/ \
    -v $PWD/docker/inputs/:/inputs/ \
    -v $PWD/docker/models/:/models/ \
    celldetection:latest /bin/bash -c \
    "python cpn_inference.py --tile_size=1024 --stride=768 --precision=32-true --accelerator=cpu"
  ```
  </details>





  You can also pull our Docker images for the use with [Apptainer](https://apptainer.org/) (formerly [Singularity](https://github.com/apptainer/singularity)) with this command:

  ```
  apptainer pull --dir . --disable-cache docker://ericup/celldetection:latest
  ```




  Find us on Hugging Face and upload your own images for segmentation: https://huggingface.co/spaces/ericup/celldetection

  There's also an API (Python & JavaScript), allowing you to utilize community GPUs (currently Nvidia A100) remotely!

  <details>
      <summary style="font-weight: bold; color: #888888">Hugging Face API</summary>



  ```python
  from gradio_client import Client


  inputs = 'https://raw.githubusercontent.com/scikit-image/scikit-image/main/skimage/data/coins.png'


  client = Client("ericup/celldetection")


  overlay_filename, img_filename, h5_filename, csv_filename = client.predict(
      inputs,  # str: Local filepath or URL of your input image

      
      'ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c',

      
      False, .9,  # bool: Whether to use custom setting; float: Custom setting

      
      False, .3142,  # bool: Whether to use custom setting; float: Custom setting

      
      False, 128,  # bool: Whether to use custom setting; int: Custom setting

      
      True,  # bool: Whether to allow overlapping objects

      
      api_name="/predict"
  )



  from matplotlib import pyplot as plt
  import celldetection as cd
  import pandas as pd


  img = imread(img_filename)
  overlay = imread(overlay_filename)  # random colors per instance; transparent overlap
  properties = pd.read_csv(csv_filename)
  contours, scores, label_image = cd.from_h5(h5_filename, 'contours', 'scores', 'labels')


  cd.imshow_row(img, img, figsize=(16, 9))
  cd.imshow(overlay)
  plt.show()


  cd.imshow_row(img, img, figsize=(16, 9))
  cd.plot_contours(contours, texts=['score: %d%\narea: %d' % s for s in zip((scores * 100).round(), properties.area)])
  plt.show()
  ```



  ```javascript
  import { client } from "@gradio/client";

  const response_0 = await fetch("https://raw.githubusercontent.com/scikit-image/scikit-image/main/skimage/data/coins.png");
  const exampleImage = await response_0.blob();

  const app = await client("ericup/celldetection");
  const result = await app.predict("/predict", [
      exampleImage,  // blob: Your input image

      // Model name (hosted model or URL)
      "ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c",

      // Custom Score Threshold (numeric value between 0 and 1)
      false, .9,  // bool: Whether to use custom setting; float: Custom setting

      // Custom NMS Threshold
      false, .3142,  // bool: Whether to use custom setting; float: Custom setting

      // Custom Number of Sample Points
      false, 128,  // bool: Whether to use custom setting; int: Custom setting

      // Overlapping objects
      true,  // bool: Whether to allow overlapping objects

      // API name (keep as is)
      api_name="/predict"
  ]);
  ```

  </details>



  Find our Napari Plugin here: https://github.com/FZJ-INM1-BDA/celldetection-napari </br>
  Find out more about Napari here: https://napari.org
  ![bbbc039](https://raw.githubusercontent.com/FZJ-INM1-BDA/celldetection-napari/main/assets/coins-demo.png "Napari Plugin")
  You can install it via pip:
  ```
  pip install git+https://github.com/FZJ-INM1-BDA/celldetection-napari.git
  ```



  - [NeurIPS 2022 Cell Segmentation Challenge](https://neurips22-cellseg.grand-challenge.org/): Winner Finalist Award



  If you find this work useful, please consider giving a **star** ⭐️ and **citation**:

  ```
  @article{UPSCHULTE2022102371,
      title = {Contour proposal networks for biomedical instance segmentation},
      journal = {Medical Image Analysis},
      volume = {77},
      pages = {102371},
      year = {2022},
      issn = {1361-8415},
      doi = {https://doi.org/10.1016/j.media.2022.102371},
      url = {https://www.sciencedirect.com/science/article/pii/S136184152200024X},
      author = {Eric Upschulte and Stefan Harmeling and Katrin Amunts and Timo Dickscheid},
      keywords = {Cell detection, Cell segmentation, Object detection, CPN},
  }
  ```



  - [Article (sciencedirect)](https://www.sciencedirect.com/science/article/pii/S136184152200024X "Contour Proposal Networks for Biomedical Instance Segmentation")
  - [PDF (sciencedirect)](https://www.sciencedirect.com/sdfe/reader/pii/S136184152200024X/pdf "Contour Proposal Networks for Biomedical Instance Segmentation")
  - [PyPI](https://pypi.org/project/celldetection/ "CellDetection")
  - [Documentation](https://docs.celldetection.org "Documentation")



  [![Stargazers repo roster for @FZJ-INM1-BDA/celldetection](http://reporoster.com/stars/FZJ-INM1-BDA/celldetection)](https://github.com/FZJ-INM1-BDA/celldetection/stargazers)
  [![Forkers repo roster for @FZJ-INM1-BDA/celldetection](http://reporoster.com/forks/FZJ-INM1-BDA/celldetection)](https://github.com/FZJ-INM1-BDA/celldetection/network/members)


pkgId: 75676d2bbb7e2673912df453e077aa29fc3e13678be6affb3b2f3a45986a9610
name: python-CellGen
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: CellGen: a computational model for predicting the cellular response to diverse perturbation
url: https://github.com/JinmiaoChenLab/CellGenpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CellGen-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <p align='center'><img src='assets/Fig1_main.png' alt='Overview.' width='100%'> </p>

  **Abstract**. Accurate prediction of cellular responses to perturbations in single-cell RNA sequencing (scRNA-seq) data is critical for advancing our understanding of complex biological processes and dis-ease mechanisms. Existing methods often struggle with generalization, particularly in out-of-sample (OOS) and out-of-distribution (OOD) scenarios, where the absence of curated cell type information or novel cell types presents significant challenges. To address these limitations, we developed a generative adversarial network (GAN)-based model called CellGen that integrates Feature-wise Linear Modulation (FiLM) layers and a modified multi-head attention mechanism to effectively model gene expression changes across diverse biological contexts. Our model excels in preserving the biological fidelity of gene expression distributions, maintaining robust gene-gene interactions, and accurately forecasting future cel-lular states, such as during the epithelial-to-mesenchymal transition (EMT). Benchmarking against state-of-the-art methods demonstrates its superior performance in both OOS and OOD predictions, without the need for cell type annotations. This study underscores the model's potential for robust and biologically relevant single-cell perturbation analysis, with implications for improving our understanding of dynamic cellular processes and disease progression.

  For reproducing the result in the paper. Please refer to this [link](https://github.com/JinmiaoChenLab/CellGen)



  We recommend to install the miniconda and then we can create the virtual environment

  ```conda create --name CellGen python=3.10```

  Next, we recommend to install the [Pytorch](https://pytorch.org/get-started/locally/) GPU version as our model is a GPU based for training.

  then all the rest of the dependency using pip installation

  ```conda activate CellGen```

  ```python -m pip install -r requirements.txt```



  To be implementated
  ``` ```




  **Out of sample and out of distribution Dataset:**
  1. [Kang et al. "Multiplexed droplet single-cell RNA-sequencing using natural genetic variation." Nature Biotechnology volume 36, pages89–94 (2018)](https://www.nature.com/articles/nbt.4042)

  **Time trajectory Dataset:**

  2. [Paul I, Bolzan D, Youssef A, Gagnon KA et al. Parallelized multidimensional analytic framework applied to mammary epithelial cells uncovers regulatory principles in EMT. Nat Commun 2023 Feb 8;14(1):688.](https://pubmed.ncbi.nlm.nih.gov/36755019/)


  [JinmiaoChenLab Github Repo](https://github.com/JinmiaoChenLab)
  [Vathanak Github Repo](https://github.com/uddamvathanak)


pkgId: 4c5f143648441f997aa5e36b2ce041172e7254a08bffaeb0259dce780497a89e
name: python-CellProfiler-nightly
arch: src
version: 5.0.0.dev143
epoch: 0
release: 1
url: https://cellprofiler.org/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CellProfiler-nightly-5.0.0.dev143-1.src.rpm
checksum_type: sha256
summary:
  CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.

description:
  This codebase contains the code to build the `cellprofiler` package. It contains modules that implement the GUI interface, the CLI interface, and others that are non-essential to the functioning of the [CellProfiler](https://cellprofiler.org) software. The [subpackages](https://github.com/CellProfiler/CellProfiler/tree/main/src/subpackages) are necessary dependencies for the functioning of `cellprofiler`.

rpm_license:
  The BSD 3-Clause License  Copyright © 2003 - 2021 Broad Institute, Inc. 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.  3.  Neither the name of the Broad Institute, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED “AS IS.”  BROAD MAKES NO EXPRESS OR IMPLIED REPRESENTATIONS OR WARRANTIES OF ANY KIND REGARDING THE SOFTWARE AND COPYRIGHT, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, CONFORMITY WITH ANY DOCUMENTATION, NON-INFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, WHETHER OR NOT DISCOVERABLE. IN NO EVENT SHALL BROAD, THE COPYRIGHT HOLDERS, 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, HAVE REASON TO KNOW, OR IN FACT SHALL KNOW OF THE POSSIBILITY OF SUCH DAMAGE.  If, by operation of law or otherwise, any of the aforementioned warranty disclaimers are determined inapplicable, your sole remedy, regardless of the form of action, including, but not limited to, negligence and strict liability, shall be replacement of the software with an updated version if one exists.  Development of CellProfiler has been funded in whole or in part with federal funds from the National Institutes of Health, the National Science Foundation, and the Human Frontier Science Program.


pkgId: a8ce649392ea076ee09a9252435c21ed361302d39230be55449e79ab6a346d19
name: python-Cemotion
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Cemotion 是 Python 下的中文 NLP 库，可以进行中文情感倾向分析、通用领域中文分词。
url: https://pypi.org/project/Cemotion/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cemotion-2.2.2-1.src.rpm
checksum_type: sha256
description:
  [中文版](#中文版)

  Cemotion is a Chinese NLP (Natural Language Processing) library for Python that can perform sentiment analysis and general domain Chinese word segmentation.

  The Cemotion 2.0 model is trained using BERT (Bidirectional Encoder Representations from Transformers), which returns a sentiment confidence score between 0 and 1 for Chinese text (sentiment polarity with 0 being negative and 1 being positive).

  Additionally, the newly added Cegementor Chinese word segmentation class uses the BAStructBERT general domain Chinese word segmentation model to segment text semantically.

  With Cemotion, you will be able to:

  - Analyze the sentiment of Chinese text in batches
  - Perform Chinese text segmentation in batches
  - Deploy to production environments such as Linux, macOS, Windows (supports Apple Silicon)

  This module depends on the PyTorch environment (which will be installed automatically) and requires Python version 3.8 or higher. Older machines may not be able to run it.

  Please note that Cemotion will automatically utilize the GPUs of NVIDIA and Apple Silicon. If there is no GPU available, it will use CPU for inference.



  1. Enter the command window and create a virtual environment by entering the following commands in sequence.

  For Linux and macOS:

  ```bash
  python3 -m venv venv # Create a virtual environment
  . venv/bin/activate # Activate the virtual environment
  ```

  For Windows:

  ```bash
  python -m venv venv # Create a virtual environment
  venv\Scripts\activate # Activate the virtual environment
  ```

  2. Install the Cemotion library by entering the following commands in sequence:

  ```bash
  pip install --upgrade pip
  pip install cemotion
  ```



  - GitHub: https://github.com/Cyberbolt/Cemotion
  - Cyberlight Notes: https://www.cyberlight.xyz/




  Analyze by text string
  ```python

  from cemotion import Cemotion

  str_text1 = '配置顶级，不解释，手机需要的各个方面都很完美'
  str_text2 = '院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！'

  c = Cemotion()
  print(f'"{str_text1}"\nPredicted value:{c.predict(str_text1)}'\n')
  print(f'"{str_text2}"\nPredicted value:{c.predict(str_text2)}'\n')
  ```


  ```

  " 配置顶级，不解释，手机需要的各个方面都很完美 "
   预测值:0.999962

  " 院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！ "
   预测值:0.000147
  ```


  Using a list for batch analysis

  ```python

  from cemotion import Cemotion

  list_text = ['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！',
  '总而言之，是一家不会再去的店。']

  c = Cemotion()
  print(c.predict(list_text))
  ```


  ```

  [['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！', 0.999962], ['总而言之，是一家不会再去的店。', 0.000194]]
  ```




  Segmentation of a single text
  ```python

  from cemotion import Cegmentor

  text = '这辆车的内饰设计非常现代，而且用料考究，给人一种豪华的感觉。'

  segmenter = Cegmentor()
  segmentation_result = segmenter.segment(text)
  print(segmentation_result)
  ```

  ```

  ['这', '辆', '车', '的', '内饰', '设计', '非常', '现代', '，', '而且', '用料', '考究', '，', '给', '人', '一', '种', '豪华', '的', '感觉', '。']
  ```


  Using a list for batch Chinese text segmentation
  ```python

  from cemotion import Cegmentor

  text = '这辆车的内饰设计非常现代，而且用料考究，给人一种豪华的感觉。'

  list_text = [
      '随着科技的发展，智能手机的功能越来越强大，给我们的生活带来了很多便利。',
      '他从小就对天文学充满好奇，立志要成为一名宇航员，探索宇宙的奥秘。',
      '这种新型的太阳能电池板转换效率高，而且环保，有望在未来得到广泛应用。'
  ]

  segmenter = Cegmentor()
  segmentation_result = segmenter.segment(list_text)
  print(segmentation_result)
  ```

  ```

  [
  ['随着', '科技', '的', '发展', '，', '智能', '手机', '的', '功能', '越来越', '强大', '，', '给', '我们', '的', '生活', '带来', '了', '很多', '便利', '。'],
  ['他', '从小', '就', '对', '天文学', '充满', '好奇', '，', '立志', '要', '成为', '一', '名', '宇航员', '，', '探索', '宇宙', '的', '奥秘', '。'],
  ['这种', '新型', '的', '太阳能', '电池板', '转换', '效率', '高', '，', '而且', '环保', '，', '有望', '在', '未来', '得到', '广泛', '应用', '。']
  ]
  ```





  1. Replaced the dependency on TensorFlow with PyTorch.

  2. Changed the old version's BRNN + LSTM to the BERT model.

  Additionally, the interface of version 2.0 remains the same as the old version, allowing for seamless switching.




  Cemotion 是 Python 下的中文 NLP 库，可以进行中文情感倾向分析、通用领域中文分词。

  Cemotion 2.0 模型使用 BERT (Bidirectional Encoder Representations from Transformers) 训练得到，会为中文文本返回 0～1 之间的情感倾向置信度 (情感极性 0 为消极，1 为积极)。

  此外，新加入的 Cegementor 中文分词类采用 BAStructBERT 通用领域中文分词模型对文本按语义进行分词。

  使用 Cemotion，您将能够：
  - 批量分析中文文本的情感
  - 批量进行中文文本分词
  - 部署至 Linux、macOS、Windows 等生产环境中 (支持 Apple Silicon)

  该模块依赖于 PyTorch 环境（会自动安装），要求 Python 3.8 或更高版本，较老的机器可能无法运行。

  注意，Cemotion 会自动调用 NVIDIA 和 Apple Silicon 的 GPU。如果没有 GPU，则使用 CPU 推理。



  1.进入命令窗口，创建虚拟环境，依次输入以下命令

  Linux 和 macOS:

  ```bash
  python3 -m venv venv #创建虚拟环境
  . venv/bin/activate #激活虚拟环境
  ```

  Windows:

  ```bash
  python -m venv venv #创建虚拟环境
  venv\Scripts\activate #激活虚拟环境
  ```

  2.安装Cemotion库，依次输入

  ```bash
  pip install --upgrade pip
  pip install cemotion
  ```



  - GitHub https://github.com/Cyberbolt/Cemotion
  - 电光笔记 https://www.cyberlight.xyz/





  单个文本进行分析

  ```python
  from cemotion import Cemotion

  str_text1 = '配置顶级，不解释，手机需要的各个方面都很完美'
  str_text2 = '院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！'

  c = Cemotion()
  print(f'"{str_text1}"\n预测值:{c.predict(str_text1)}\n')
  print(f'"{str_text2}"\n预测值:{c.predict(str_text2)}\n' )
  ```


  ```

  " 配置顶级，不解释，手机需要的各个方面都很完美 "
   预测值:0.999962

  " 院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！ "
   预测值:0.000147
  ```

  使用列表进行批量分析

  ```python
  from cemotion import Cemotion

  list_text = ['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！',
  '总而言之，是一家不会再去的店。']

  c = Cemotion()
  print(c.predict(list_text))
  ```


  ```

  [['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！', 0.999962], ['总而言之，是一家不会再去的店。', 0.000194]]
  ```



  单个文本进行分词

  ```python
  from cemotion import Cegmentor

  text = '这辆车的内饰设计非常现代，而且用料考究，给人一种豪华的感觉。'

  segmenter = Cegmentor()
  segmentation_result = segmenter.segment(text)
  print(segmentation_result)
  ```

  ```

  ['这', '辆', '车', '的', '内饰', '设计', '非常', '现代', '，', '而且', '用料', '考究', '，', '给', '人', '一', '种', '豪华', '的', '感觉', '。']
  ```

  使用列表进行批量中文分词

  ```python
  from cemotion import Cegmentor

  text = '这辆车的内饰设计非常现代，而且用料考究，给人一种豪华的感觉。'

  list_text = [
      '随着科技的发展，智能手机的功能越来越强大，给我们的生活带来了很多便利。',
      '他从小就对天文学充满好奇，立志要成为一名宇航员，探索宇宙的奥秘。',
      '这种新型的太阳能电池板转换效率高，而且环保，有望在未来得到广泛应用。'
  ]

  segmenter = Cegmentor()
  segmentation_result = segmenter.segment(list_text)
  print(segmentation_result)
  ```

  ```

  [
  ['随着', '科技', '的', '发展', '，', '智能', '手机', '的', '功能', '越来越', '强大', '，', '给', '我们', '的', '生活', '带来', '了', '很多', '便利', '。'],
  ['他', '从小', '就', '对', '天文学', '充满', '好奇', '，', '立志', '要', '成为', '一', '名', '宇航员', '，', '探索', '宇宙', '的', '奥秘', '。'],
  ['这种', '新型', '的', '太阳能', '电池板', '转换', '效率', '高', '，', '而且', '环保', '，', '有望', '在', '未来', '得到', '广泛', '应用', '。']
  ]
  ```





  1.替换依赖 TensorFlow 为 PyTorch

  2.将老版本的 BRNN + LSTM 更改为 BERT 模型

  此外，2.0 版本的接口和老版本保持相同，您可以无缝切换。


pkgId: 0742bb1d570e4c7612f21bb143c7818692980ae189293fbc9d2bab5ece2be037
name: python-Cemotion-apple
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: 基于NLP的中文情感倾向分析库
url: https://pypi.org/project/Cemotion-apple/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cemotion-apple-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Cemotion是Python下的中文NLP库，可以进行 中文情感倾向分析。

  Cemotion的模型经循环神经网络训练得到，会为 中文文本 返回 0～1之间的 情感倾向置信度。您可以批量分析中文文本的情感，并部署至Linux、macOS、Windows等生产环境中，无需关注内部原理。

  该模块供Apple Silicon使用，已经过M1测试。请按该文档安装ARM Python、TensorFlow、scikit-learn环境。





  前提:
  根据 [https://www.cyberlight.xyz/passage/tensorflow-apple-m1](https://www.cyberlight.xyz/passage/tensorflow-apple-m1) 此文方法安装ARM Python和TensorFlow（TensorFlow需要装到conda虚拟环境中，通读全文后，请使用文章末尾的方法安装TensorFlow）

  此时，我们假定您已安装相关环境，并创建了名为py38的conda虚拟环境

  1.进入命令窗口，激活conda虚拟环境，安装scikit-learn


  ```
  conda activate py38 #激活虚拟环境 此处虚拟环境名称为py38（您可以自定义名称）
  conda install scikit-learn #安装scikit-learn
  ```


  之后输入以下命令安装Cemotion
  ```
  pip install --upgrade pip
  pip install cemotion-apple
  ```




  ```

  from cemotion import Cemotion

  str_text1 = '配置顶级，不解释，手机需要的各个方面都很完美'
  str_text2 = '院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！'

  c = Cemotion()
  print('"', str_text1 , '"\n' , '预测值:{:6f}'.format(c.predict(str_text1) ) , '\n')
  print('"', str_text2 , '"\n' , '预测值:{:6f}'.format(c.predict(str_text2) ) , '\n')
  ```


  ```

  text mode
  " 配置顶级，不解释，手机需要的各个方面都很完美 "
   预测值:0.999931

  text mode
  " 院线看电影这么多年以来，这是我第一次看电影睡着了。简直是史上最大烂片！没有之一！侮辱智商！大家小心警惕！千万不要上当！再也不要看了！ "
   预测值:0.000001
  ```




  ```

  from cemotion import Cemotion

  list_text = ['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！',
  '总而言之，是一家不会再去的店。']

  c = Cemotion()
  print(c.predict(list_text))
  ```


  ```

  list mode
  [['内饰蛮年轻的，而且看上去质感都蛮好，貌似本田所有车都有点相似，满高档的！', 0.999907], ['总而言之，是一家不会再去的店。', 0.049015]]
  ```


pkgId: a6043ca06515ce6e97e546d4c050e7cb7dc531ce2f35af99b3bce3d9a7a653cd
name: python-CensusData
arch: src
version: 1.15.post1
epoch: 0
release: 1
summary: Download data from U.S. Census API
url: https://github.com/jtleider/censusdata
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CensusData-1.15.post1-1.src.rpm
checksum_type: sha256
description:
  *NOTE: as of March 28, 2022, I am unable to continue providing updates to this
  package. While it should still work for the release years it was originally
  written for, I cannot guarantee that. The code is freely available for
  modification as needed for the years the package was written for, or
  to add support for more recent years of data.*

  This package is designed to provide easy access to the U.S. Census Bureau's
  API (https://www.census.gov/developers/) in Python. It supports pulling data
  from the American Community Survey (ACS) and the Census Summary File,
  specifically:

  * ACS 5-year estimates (2005-2009 to 2015-2019),
  * ACS 1-year estimates (2012-2019),
  * ACS 3-year estimates (2010-2012 to 2011-2013),
  * ACS 1-year supplemental estimates (2014-2019),
  * Census 2010 Summary File 1.

  This package handles the details of interacting with the Census API for you,
  so that you can focus on working with the data. It provides a class for
  representing Census geographies. It also provides functions
  for gaining further information about specific variables and tables and
  for searching for variables. Full documentation is available at
  https://jtleider.github.io/censusdata/.

  The ACS (https://www.census.gov/programs-surveys/acs/)
  started in 2005. It provides information on a wide range of social, economic,
  demographic, and housing characteristics. Topics covered include
  income, employment, health insurance, the age distribution, and education, among
  many others. The ACS replaces the old Census long form, which used to be
  distributed to a subset of households responding to the decennial Census.
  The ACS produces survey-based period estimates. For instance, the
  5-year 2011-2015 estimates are based on data collected during all 5 years.
  They are not simply an aggregate of 1-year estimates, and overlapping
  5-year estimates (e.g., 2008-2012 and 2011-2015) should *not* be compared.
  The ACS provides margins of error to accompany all estimates. Margins of
  error are smaller for estimates based on more years of data.

  ACS 5-year estimates are the least current but provide the greatest precision
  and are available for geographies of all sizes
  (https://www.census.gov/programs-surveys/acs/guidance/estimates.html). By
  contrast, 1-year estimates are the most current but the least precise and are
  only available for geographies with populations of 65,000+.
  In between are the 1-year supplemental estimates or, in past years, the
  3-year estimates, both of which are for geographies with populations of
  20,000+. The choice of which ACS estimates to use will depend on your needs
  for current data vs. data for a variety of geographies with greater
  precision.

  The decennial Census counts every resident of the United States. The 2010
  Census Summary File 1 provides information about each community's population,
  including age, sex, and race distributions, as well as information
  on households and families. (Summary File 2 provides additional data
  for specific racial/ethnic groups.)

  There are a number of facilities available for downloading Census
  data, including American FactFinder, the ACS summary files,
  and the Census DataFerrett. This package is designed to provide
  the following features not available elsewhere:

  * Easy download of specific variables across a variety of tables, downloading only the variables you need for the geographies of interest to you. This bypasses data processing hassles associated with working with other sources like the ACS Summary Files.
  * Access to the exact variables of interest, with variable names making it easy to look up further information on the source tables or to pull up other years of data. This facilitates work by more technical users.
  * Download data for multiple geographies at once, such as all counties in the United States, or all block groups in Illinois.
  * Work with the data as a Pandas data frame, or export to CSV for analysis in other data analysis packages.


pkgId: 5ddff7259181ae295319618f43ca67db72d8a58e808238b30d152dab43db658e
name: python-Cerberus
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: Lightweight, extensible schema and data validation tool for Pythondictionaries.
url: https://pypi.org/project/Cerberus/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cerberus-1.3.5-1.src.rpm
checksum_type: sha256
description:
  |python-support| |black|
  Cerberus is a lightweight and extensible data validation library for Python.
      >>> v = Validator({'name': {'type': 'string'}})
      >>> v.validate({'name': 'john doe'})
      True

rpm_license:
  ISC License  Copyright (c) 2012-2016 Nicola Iarocci.  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 7ad85298a874282a358af33f138abd4d31180315defe9d4ddef773786ad5d80d
name: python-CfgNet
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: A Framework for Tracking Configuration Dependencies Across a Software Project
url: https://github.com/digital-bauhaus/CfgNet
rpm_license: GPL-3.0+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CfgNet-1.0.4-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/AI-4-SE/CfgNet/workflows/Tests/badge.svg?branch=main)
  ![](https://github.com/AI-4-SE/CfgNet/workflows/Code%20Style/badge.svg?branch=main)



  CfgNet is a plugin-based framework for detecting and tracking dependencies among configuration options across the used technology stack of a software project.
  Essentially, CfgNet represents configuration options of configuration artifacts as trees and connects them to build a configuration network, where links between the leaf nodes of a tree correspond to the dependencies between configuration options.
  Our idea is to have a framework in which technology plugins analyze different configuration files (e.g., Dockerfiles or build scripts) and create nodes for configuration options with their user-defined values.
  Linker plugins then connect the nodes in case a dependency exists using a specific linker heuristic.

  We envision that CfgNet is used within a Git hook (e.g., pre-commit hook) to prevent dependency conflicts during the development and maintenance of software systems.
  That is, whenever changes are made, CfgNet can check the changes before the actual commit gets pushed to the repository and reports a warning if it has detected possible dependency conflicts.
  This way, developer can check the changes again and even use the information that CfgNet provides to fix the dependency conflicts.



  CfgNet is a package on PyPI. You can install it with the following command:

      pip install cfgnet

  You can also build it locally with [poetry](https://python-poetry.org/).
  Please refer to the documentation of poetry for further details.



  CfgNet provides a method-based command line interface with the commands `init`, `validate`, `export`, `analyze`, and `extract`.
  Each method requires the `project_root` as option that points towards the root directory of the project on which you want to apply the CfgNet.

  To initialize a reference configuration network, use the `init` command.

      cfgnet init <project_root>


  To detect dependency conflicts against the initialized reference network, you need to call
  the `validate` command. Detected dependency conflicts will be displayed on screen.

      cfgnet validate <project_root>


  To export the reference network for visualization, use the `export` command.
  The `export` command additionally requires a `output` and `format` option.
  While the former specifies the name of the output file the latter defines which format the configuration network should be converted to.
  Available formats are `json` and `dot`.
  By default, the export includes only linked value nodes.
  To export all nodes from the configuration network, you have te set the option `include-unlinked`.

      cfgnet export --output=<name> --format=<format> <project_root>
      cfgnet export --output=<name> --format=<format> --include-unlinked <project_root>

  To visualize the reference network immediately without exporting the format, use the `export` command with the `-visualize-dot` option.
  The visualization of the configuration network is stored in `.cfgnet/export` using the `png` format by default.
  However, the format can be changed to either `pdf` or `png` using the format option.
  By default, the network visualization includes only linked value nodes.
  To visualize the entire configuration network including value nodes that are not linked to other nodes, you have to set the option `include-unlinked`.

      cfgnet export --output=<name> --visualize-dot <project_root>
      cfgnet export --output=<name> --format=<format> --visualize-dot <project_root>
      cfgnet export --output=<name> --format=<format> --include-unlinked --visualize-dot <project_root>

  The `analyze` command is used for analyzing the commit history of software systems in an automated manner.
  When the analysis is finished, all detected configuration conflicts will be stored in `.cfgnet/analysis`.

      cfgnet analyze <project_root>

  To extract the key-value pairs of all configuration artifacts within a software project, use the `extract` command. The `extract` command additionally requires an `output` options, which specifies the directory where the key-value pairs are stored using the JSON format.

      cfgnet extract <project_root> --output=<output>

  The commands `init` and `analyze` can be further configured with the following options:

      (1) --enable-static-blacklist
      (2) --enable-internal-conflicts
      (3) --enable-all-conflicts
      (4) --config-files=<absolute_file_path>

  These options enable (1) blacklisted values, which are taken into account when creating links, (2) the detection of conflicts within the same configuration artifact, (3) the detection of all conflict types, and (4) parsing of specific configuration files (e.g., configuration files of the operating machine that are not in the git repository of the software project), respectively. The option `--config-files` can be specified multiple times. The `config-file` option can also be used to configure the `extract` command.

  For a documentation of further options run

      cfgnet --help



  You can build the documentation with

      make docs

  The HTML version of the documentation will be in `docs/_build/html`.



  To contribute to this project feel free to create pull requests.
  Please read our [guidelines and instructions for development][development] first.

  [releases]: https://github.com/AI-4-SE/CfgNet/releases
  [development]: docs/development.rst


pkgId: 83d7ac4803891d26d955fc054365cc19e5890b65b11994363b81915333e7a787
name: python-ChIP-R
arch: src
version: 1.2.0
epoch: 0
release: 1
url: https://github.com/rhysnewell/ChIP-R
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChIP-R-1.2.0-1.src.rpm
checksum_type: sha256
summary:
  ChIP-R is a method for assessing the reproducibility of replicated ChIP-seq type experiments. It incorporates the rank product method, a novel thresholding methods, and the use of peak fragmentation return the most reproducible peaks.

description:
  ChIP-R uses an adaptation of the rank product statistic to assess the reproducibility of ChIP-seq peaks by incorporating information from multiple ChIP-seq replicates and "fragmenting" peak locations to better combine the information present across the replicates.


pkgId: 4e25cb09025a7300f60d34693ffe7ff9486a03737b839a4dfaf666e1d320d040
name: python-ChainConsumer
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: ChainConsumer: Consumer your MCMC chains
url: https://pypi.org/project/ChainConsumer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChainConsumer-1.1.3-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/eefe9aa7d4904306877be1e17b952f39)](https://www.codacy.com/app/samuelreay/ChainConsumer?utm_source=github.com&utm_medium=referral&utm_content=Samreay/ChainConsumer&utm_campaign=badger)
  [![Build Status](https://img.shields.io/travis/Samreay/ChainConsumer.svg)](https://travis-ci.org/Samreay/ChainConsumer)
  [![Coverage Status](https://codecov.io/gh/Samreay/ChainConsumer/branch/master/graph/badge.svg)](https://codecov.io/gh/Samreay/ChainConsumer)
  [![License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/dessn/abc/blob/master/LICENSE)


  [![PyPi](https://img.shields.io/pypi/v/ChainConsumer)](https://pypi.python.org/pypi/ChainConsumer)
  [![Conda](https://anaconda.org/samreay/chainconsumer/badges/version.svg)](https://anaconda.org/samreay/chainconsumer)
  [![DOI](https://zenodo.org/badge/23430/Samreay/ChainConsumer.svg)](https://zenodo.org/badge/latestdoi/23430/Samreay/ChainConsumer)
  [![JOSS](http://joss.theoj.org/papers/10.21105/joss.00045/status.svg?style=flat)](http://dx.doi.org/10.21105/joss.00045)

  A library to consume your fitting chains! Produce likelihood surfaces,
  plot your walks to check convergence, output a LaTeX table of the
  marginalised parameter distributions with uncertainties and significant
  figures all done for you, or throw in a bunch of chains from different models
  and perform some model selection!

  [Click through to the online documentation](https://samreay.github.io/ChainConsumer)



  Install via `pip`:

      pip install chainconsumer



  Time has ticked on, and now only python 3.10 will be supported. This is because type hints are amazing.



  1. Clone repo
  2. Run `make install`
  3. Ensure that you set your python interpreter to the `.venv/bin/python`
  4. Code away.



  I would like to thank the following people for their contribution in issues, algorithms and code snippets
  which have helped improve ChainConsumer:

  * Simon Dupourqué (for his PRs and suggestions to make ChainConsumer better for all)
  * Chris Davis (check out https://github.com/cpadavis/preliminize)
  * Joe Zuntz
  * Scott Dedelson
  * Elizabeth Krause
  * David Parkinson
  * Caitlin Adams
  * Tom McClintock
  * Steven Murray
  * J. Michael Burgess
  * Matthew Kirby
  * Michael Troxel
  * Eduardo Rozo
  * Warren Morningstar




  Users on some Linux platforms have reported issues rendering plots using ChainConsumer.
  The common error states that `dvipng: not found`, and as per [StackOverflow](http://stackoverflow.com/a/32915992/3339667)
  post, it can be solved by explicitly install the `matplotlib` dependency `dvipng` via `sudo apt-get install dvipng`.

  If you are running on HPC or clusters where you can't install things yourself, users may run into issues where LaTeX or other optional dependencies aren't installed. In this case, set `usetex=False` in `configure` to request matplotlib not try to use TeX. If this does not work, also set `serif=False`, which has helped some uses.




  * Switch `scipy.integrate.simps` to `scipy.integrate.simpsons` for compatibility with new releases


  * Adding general `kwargs` to `add_marker` so one can pass `show_label_in_legend` and other customisations through.


  * Updating numpyro and arviz translators so you can specify variable names (`var_names`) to include or exclude.
  * Adding `histogram_relative_height` property to chains to control histogram height.
  * Adding `show_label_in_legend` so you can decide to give a chain a label but not have it pollute the legend.


  * Bug fix not using labels instead of column names for parameter title summaries.


  * Bug fix for chain divisions.


  * Bug fix for the truth labels.


  * Huge update to make full use of type hints, pydantic v2, and mkdocs


  * Making `usetex=False` and `serif=False` the defaults to reduce LaTeX errors.

  * Adding extra padding to bin extents for KDE and smoothing
  * Updating watermarking to work with matplotlib v3.0.0+


  * Fixing matplotlib axis formatter issue.


  * Conda-forge updates


  * Adding ability to display plot as a prior (1D only, no 2D)


  * Linking colorbar label font size to global label font size option. Thanks Yucheng-Zhang!
  * Allowing chains to be passed in as a pandas DataFrame.
  * Statsmodel update means we are now switching to Python 3 only support.


  * Updating `matplotlib` dependency version for conda install. Thanks He Jia!


  * Bug fix for specifying numeric `loc` to `legend_kwargs`
  * Added `shift_params` when adding chains.


  * Potential bug fix for `log_space` feature.



  * Warning the user if `configure` is called multiple times.
  * Allowing parameters to be a number when calling `get_latex_table`
  * Adding log scales when plotting.
  * Adding the ability to plot a contour on an arbitrary axis via new method `plot_contour`



  * Removing `rainbow` option and replacing with `cmap` so you can specify the cmap used, not just rainbow.
  * Adding `zorder` configuration option to epxlicitly order contours.
  * Adding extra checks to try and catch bad chains on load.


  * Now restores default `rcParams` for `usetex` and `font-family` after plotting.
  * All logging now under logger name `chainconsumer` to make it easy to hide if needed.
  * Formula for computing `shade_alpha` now uses sqrt(num_chains) instead of num_chains.
  * `get_latex_table` now accepts a filename input to save the parameters to.
  * Adding `add_covariance` to compliment `add_chain` - useful for Fisher matrix forecasts and similar. Just invert it first for me.
  * Adding `add_marker` to allow easy inclusion of markers in the plots.


  * Adding ability to turn off chain names in `plot_summary`.


  * Fixing bug with `plot_walks` that required truth values.
  * Fixing flaw in `configure` to allow for updating values.
  * Fixing bug where summary values are cached without reference to the summary statistic method.


  * Adding ability to plot maximum points on 2D contour, not just global posterior maximum.
  * Fixing truth dictionary mutation on `plot_walks`


  * Adding ability to pass in a power to raise the surface to for each chain.
  * Adding methods to retrieve the maximum posterior point: `Analysis.get_max_posteriors`
  * Adding ability to plot maximum posterior points. Can control `marker_size`, `marker_style`, `marker_alpha`, and whether to plot contours, points or both.
  * Finishing migration of configuration options you can specify when adding chains rather than configuring all chains with `configure`.


  * (Attempting to) enable fully automated releases to Github, PyPI, Zenodo and conda.


  * (Attempting to) enable fully automated releases to Github, PyPI, Zenodo and conda.


  * Changing default `sigma2d` to `False`. *May chance how your plots are displayed*.
  * Allowing format specification when adding chains.
  * Making `yule_walker` (and thus all of `statsmodels`) a conditional import.
  * Updating minimum version of requirements to reduce issues with install.


  * Fixing bug in label rendering for contour sigma labels.
  * Improving parsing of `sigma` in `configure`, such that you don't need a leading zero.


  * Fixing bug in `get_correlations`.


  * Changing default colour order.
  * Improving behaviour of `shade_gradient`.


  * Refactoring project structure.
  * Updating colours for better legibility.
  * Setting `shade=True` automatically if `shade_alpha` is overriden.


  * Removing `bbox_inches="tight"` due to a bug in matplotlib v2.1.0.
  * Adding more colour shortcuts.


  * Making rainbow colours slightly more visible by darkening the yellow regions.


  * Can now pass a list of filenames to save out, to make generating a PNG and PDF option in one go easier
  * Adding method `plot_summary`


  * Adding option to specify the confidence interval (area) for parameter summaries.
  * Adding three extra methods for parameter summaries from Andrae 2010: max symmetric, max shortest and max central stats.


  * Fixing a bug that caused ChainConsumer to crash in some cases when you specified a number of parameters.


  * Fixing bug that made parameter ordering incorrect in some circumstances.


  * Fixing error when plotting walks with small weights.


  * Fixing issue where refactoring broke parameter blinding.


  * ChainConsumer now only finds extents of relevant parameters when plotting, instead of all parameters.


  * Updating extents so previous updates do something.


  * Adding example and code to deal with non-TeX watermarks.


  * Increasing extents again.
  * Updating legend defaults.
  * Code refactor.
  * Can now specify which chains to plot when plotting contours.
  * Adding watermark text.


  * Increase control over legend with kwargs.
  * Can specify legend subplot location.
  * Increased legend options with coloured text.
  * Added `shade_gradient` option.
  * Increase the amount of default extent given.


  * Adding ability to blind parameters.


  * Adding ability to plot contour levels, either in confidence levels or sigma.
  * Changed shading defaults.


  * Legend gets placed in top right corner now when `plot_hsits` is `False` and there are only two parameters.


  * `sigma2d` correctly defaults to `True` now.


  * Adding log_weights to the detected colour parameters.
  * Contours now support 1D Gaussian levels *and* 2D Gaussian levels (thanks @matthewkirby).


  * Adding Matched Elliptical Gaussian Kernel Density Estimator to replace statsmodels KDE.


  * Fixing bug in covariance calculation when getting the LaTeX table (did not affect contours)


  * Default figure size is now 1.5 inches per parameter, instead of 1. Also decreasing default font size, so that printing summaries is less likely to overlap surfaces.


  * Label font size now applies to legend.


  * Code quality improvements
  * Documentation update


  * Refactoring ChainConsumer due to growing size.
  * Improve bin limits to reduce overly large bins that form when some low-weight samples are located far away from the mean.
  * Fixed issue generating text with one sided distributions.
  * Adding ability to specify weights or posterior as the colour parameter.
  * Color scatter with uniform weights doesn't have first plot a different color.
  * Adding ability to control subplot spacing.
  * Adding method `plot_distributions` to quickly plot marginalised distributions.


  * Fixing bug in Gelman-Rubin diagnostic. Thanks Warren!


  * Moving `rc` parameters before plot creation to fix issues with parallel plot generation.


  * Fixing an integer division bug where python 2 contour shading was setting to 0 alpha.


  * Fixing bug where tick font size was only honoured when ticks were on an angle.


  * Adding ability to specify label font size, tick font size, and whether the ticks should be on an angle.


  * Bug fix for those with latest `numpy` which removed a deprecated method I was using.
  * Adding ability to get parameter covariance tables.


  * Adding ability to get parameter correlation tables.


  * Removing unnecessary debug output.


  * Can remove lists of chains properly now.


  * Adding ability to remove chains.


  * Adding ability to plot the walks of multiple chains together.


  * Removing unnecessary debug output.


  * Bugfix for python 2.7


  * Adding `usetex` to `configure` method.
  * When plotting walks, plots weights in log space if the mean weight is less than 0.1
  * Adding AIC
  * Adding BIC
  * Adding DIC
  * Adding method to output model comparison table.


  * Adding coloured scatter.
  * Disallowing grid data and KDE.
  * Adding more examples.
  * Consolidating all configures into one method.
  * Improved extent finding.
  * Updating smoothing to use reflect and not constant.
  * Improving `max` statistics being able to find ranges on cliff edges.
  * Printing parameter summaries without parameter labels.


  * Removing ability to having vectorised dictionary inputs for grid data due to 2.7 compatibility issues.


  * Fixing bug when smoothing grid data.
  * Adding more input options.
  * Grids can now be specified using a list of parameter vectors.


  * Better determination of extents for data with extreme weighting.
  * Able to scale figure size using float when plotting.


  * Modifying API defaults for smoothing with grid data.
  * Allowing both smoothing and bins to be passed in as lists.


  * Adding support for grid data.


  * Fixing bug in Gelman-Rubin statistic


  * Improving text labels again.


  * Improving text labels for high value data.


  * Adding Gelman-Rubin and Geweke diagnostic methods.


  * Adding options for alternate statistics.


  * Updating setup so that dependencies are automatically installed.


  * Modifying the ``add_chain`` API, so that you can pass dictionaries!


  * Smarter extent tick labels and offsets.
  * Adding list based line styles, widths, shading and opacity.
  * Adding two more examples.


  * Preconfiguring logging.


  * Adding 2D Gaussian smoothing for the contour surfaces.
  * Renaming ``contourf`` and ``contourf_alpha`` to ``shade`` and ``shade_alpha``.
  * Updating some of the example plots.


  * Updating package setup scripts.


  * Updating package setup scripts.


  * Adding markdown paper.


  * Updating setup and package details


  * Initial zenodo release


  * Adding in smoothing, making it default
  * Adding extra example to show how to remove smoothing.


  * Adding in tests


  * Initial PyPi push


pkgId: c11ac72c7d952f7490bc7c1615b738881678e1e13912edd4c067d8214c382a3a
name: python-ChalcedonPy
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: My first Python package
url: https://pypi.org/project/ChalcedonPy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChalcedonPy-0.0.6-1.src.rpm
checksum_type: sha256
description:
  This Package is designed for to be used in lectures to teach concepts and simplify certain operations.



  Currently ChalcedonPy support the following lectures:



  1 - Electrodynamics

  2 - Digital Image Processing

  3 - Higher Mathematics

  4 - Data Science

  5 - Machine Learning


pkgId: 4930811b88a4736865b7940efb6c9d136043813334ae369cbbc1eb58d4eb5fc3
name: python-Chameleon
arch: src
version: 4.5.4
epoch: 0
release: 1
summary: Fast HTML/XML Template Compiler.
url: https://chameleon.readthedocs.io
rpm_license: BSD-like (http://repoze.org/license.html)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chameleon-4.5.4-1.src.rpm
checksum_type: sha256
description:
  Chameleon is an HTML/XML template engine for `Python
  <http://www.python.org>`_. It uses the *page templates* language.
  You can use it in any Python application with just about any
  version of Python (3.9+ and up, plus `pypy 3
  <http://pypy.org>`_).
  Visit the `documentation <https://chameleon.readthedocs.io/en/latest/>`_
  for more information.


pkgId: caa8efd4f0c02d882725aec3953a6bc94e5d4800fc60d5907599808cba32cd2c
name: python-ChangePointDetectorEVT
arch: src
version: 0.0.18
epoch: 0
release: 1
url: https://github.com/mhaupt63/ChangePointDetector
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChangePointDetectorEVT-0.0.18-1.src.rpm
checksum_type: sha256
summary:
  This module takes a date time series and returns: (a) the underlaying linear trend and (b) the times where there is a change in the trend

description:
  ChangePointDetector

  This module returns change points in a date time series, using Kalman filters and EVT as described in https://www.robots.ox.ac.uk/~sjrob/Pubs/LeeRoberts_EVT.pdf

  1. from ChangePointDetector import ChangePointDetector
  2. Prepare your time series as data plus Panda dates
  3. Create  the necessary Kalman representation by creating a "session" object by calling the ChangePoint class, e.g.:
  	Session=ChangePointDetector.ChangePointDetectorSession(data,dates).
  	- 'SeasonalityPeriods' is an optional input, e.g if your data is sequential months, 12 = calendar month seasonality
  	- 'ForecastPeriods' is another optional input, indicating how many periods to forecast.  Default = 3
  4. Determine the changepoints by running the ChangePointDetectorFunction on your "session", e.g. Results=Session.ChangePointDetectorFunction()
     This will return a "Results" object that contains the following:
  	- ChangePoints. This is a list of 0s and 1s the length of the data, where 1s represent changepoints
  	- Prediction. This is the Kalman smoothed actuals, plus a 3 period forecast. Note no forecast will be made if there is a changepoint in the last 3 			dates
  	- PredictionVariance.  Variance of the smoothed actuals and forecast
  	- ExtendedDates. These are the original dates plus 3 exta for the forecast (if a forecast has been made)
  	- Trend. This is the linear change factor
  	- TrendVariance. Variance of the trend


pkgId: aec012171b823deeb847225ab9575f41a6e937653034e27954a42354de9312c1
name: python-CharActor
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A module for creating and managing rpg characters.
url: https://github.com/primal-coder/CharActor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CharActor-1.0.5-1.src.rpm
checksum_type: sha256
description:
  CharActor provides a convenient collection of character-based operations. It allows you to easily create, modify and employ characters in a variety of different ways.



  ```bash
  pip install CharActor
  ```



  ```python
  from CharActor import character_bank, create


  character = create()


  character = create(name='John Doe')


  character = create('my_character', 'John Doe', 'Human', 'Fighter', 'Noble', 'Lawful Good')


  my_character = character_bank.my_character


  my_character.name # 'John Doe'
  my_character.Strength # Str: 17 (+3)
  ```



  A character object contains a variety of attributes/methods which tend to differ from character to character.



  * name
  * _role (e.g my_character.Fighter)
  * _race (e.g my_character.Human)
  * _background (e.g my_character.Noble)
  * _alignment (e.g my_character.LawfulGood)
  * age
  * Strength
  * Dexterity
  * Constitution
  * Intelligence
  * Wisdom
  * Charisma
  * actions
  * armor_class
  * character_sheet (e.g print(my_character.character_sheet))
  * entity_id
  * experience
  * hp
  * initiative
  * inventory
  * level
  * saving_throws
  * skill_points
  * skillbook
  * speed
  * target



  * attack
  * look_around
  * move
  * pickup
  * saving_throw
  * end_turn



  The character bank is a collection of all the characters that have been created. It is a dictionary of character objects, with the key being the name of the character. More conveniently, the character bank also allows you to access the characters as attributes. A saving system(using python's pickle) is currently under development. Until then your character's are only saved for the duration of the program.

  ```python
  from CharActor import character_bank, create


  character = create('my_character')


  my_character = character_bank.my_character
  print(my_character.character_sheet)
  ```




  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.



  [MIT](https://choosealicense.com/licenses/mit/)



  If you like this project or are just feeling generous, consider buying me a coffee.

  [buymeacoffee](https://www.buymeacoffee.com/primalcoder)


pkgId: 7be40b9ebd501e290254096e18fe9464a4466f799dd5d6b96e1caf4fd7ecf02b
name: python-ChatDBG
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: AI-assisted debugging. Uses AI to answer 'why'.
url: https://github.com/plasma-umass/ChatDBG
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChatDBG-0.6.5-1.src.rpm
checksum_type: sha256
description:
  by [Emery Berger](https://emeryberger.com), [Stephen Freund](https://www.cs.williams.edu/~freund/index.html), [Kyla Levin](https://khlevin.github.io/KylaHLevin/index.html), [Nicolas van Kempen](https://nvankempen.com/) (ordered alphabetically)

  [![PyPI Latest Release](https://img.shields.io/pypi/v/chatdbg.svg)](https://pypi.org/project/chatdbg/)
  [![Downloads](https://static.pepy.tech/badge/chatdbg)](https://pepy.tech/project/chatdbg)
  [![Downloads](https://static.pepy.tech/badge/chatdbg/month)](https://pepy.tech/project/chatdbg)

  ChatDBG is an AI-based debugging assistant for C/C++/Python/Rust code that integrates large language models into a standard debugger (`pdb`, `lldb`, `gdb`, and `windbg`) to help debug your code. With ChatDBG, you can engage in a dialog with your debugger, asking open-ended questions about your program, like `why is x null?`. ChatDBG will _take the wheel_ and steer the debugger to answer your queries. ChatDBG can provide error diagnoses and suggest fixes.

  As far as we are aware, ChatDBG is the *first* debugger to automatically perform root cause analysis and to provide suggested fixes.

  **Watch ChatDBG in action!**
  | LLDB on [test-overflow.cpp](https://github.com/plasma-umass/ChatDBG/blob/main/samples/cpp/test-overflow.cpp) | GDB on [test-overflow.cpp](https://github.com/plasma-umass/ChatDBG/blob/main/samples/cpp/test-overflow.cpp)  | Pdb on [bootstrap.py](https://github.com/plasma-umass/ChatDBG/blob/main/samples/python/bootstrap.py) |
  |:-------------------------:|:-------------------------:|:-------------------------:|
  | <a href="https://asciinema.org/a/RsAGFFmsicIvMW8xgvPP6PW2f" target="_blank"><img src="https://raw.githubusercontent.com/plasma-umass/ChatDBG/main/media/lldb.svg" /></a>| <a href="https://asciinema.org/a/bMWOyyrh7WXWsTCFboyKpqwTq" target="_blank"><img src="https://raw.githubusercontent.com/plasma-umass/ChatDBG/main/media/gdb.svg" /></a>|<a href="https://asciinema.org/a/qulxiJTqwVRJPaMZ1hcBs6Clu" target="_blank"><img src="https://raw.githubusercontent.com/plasma-umass/ChatDBG/main/media/pdb.svg" /></a>|

  For technical details and a complete evaluation, see our arXiv paper, [_ChatDBG: An AI-Powered Debugging Assistant_](https://arxiv.org/abs/2403.16354) ([PDF](https://github.com/plasma-umass/ChatDBG/blob/main/ChatDBG-arxiv-2403.16354.pdf)).

  > [!NOTE]
  >
  > ChatDBG for `pdb`, `lldb`, and `gdb` are feature-complete; we are currently backporting features for these debuggers into the other debuggers.
  >



  > [!IMPORTANT]
  >
  > ChatDBG currently needs to be connected to an [OpenAI account](https://openai.com/api/). _Your account will need to have a positive balance for this to work_ ([check your balance](https://platform.openai.com/account/usage)). If you have never purchased credits, you will need to purchase at least \$1 in credits (if your API account was created before August 13, 2023) or \$0.50 (if you have a newer API account) in order to have access to GPT-4, which ChatDBG uses. [Get a key here.](https://platform.openai.com/account/api-keys)
  >
  > Once you have an API key, set it as an environment variable called `OPENAI_API_KEY`.
  >
  > ```bash
  > export OPENAI_API_KEY=<your-api-key>
  > ```

  Install ChatDBG using `pip` (you need to do this whether you are debugging Python, C, or C++ code):

  ```bash
  python3 -m pip install chatdbg
  ```

  If you are using ChatDBG to debug Python programs, you are done. If you want to use ChatDBG to debug native code with `gdb` or `lldb`, follow the installation instructions below.



  <details>
  <summary>
  <B><TT>lldb</TT> installation instructions</B>
  </summary>

  Install ChatDBG into the `lldb` debugger by running the following command:



  ```bash
  python3 -m pip install ChatDBG
  python3 -c 'import chatdbg; print(f"command script import {chatdbg.__path__[0]}/chatdbg_lldb.py")' >> ~/.lldbinit
  ```

  If you encounter an error, you may be using an older version of LLVM. Update to the latest version as follows:

  ```
  sudo apt install -y lsb-release wget software-properties-common gnupg
  curl -sSf https://apt.llvm.org/llvm.sh | sudo bash -s -- 18 all

  ```



  ```bash
  xcrun python3 -m pip install ChatDBG
  xcrun python3 -c 'import chatdbg; print(f"command script import {chatdbg.__path__[0]}/chatdbg_lldb.py")' >> ~/.lldbinit
  ```

  This will install ChatDBG as an LLVM extension.
  </details>



  <details>
  <summary>
  <B><TT>gdb</TT> installation instructions</B>
  </summary>

  Install ChatDBG into the `gdb` debugger by running the following command:

  ```bash
  python3 -m pip install ChatDBG
  python3 -c 'import chatdbg; print(f"source {chatdbg.__path__[0]}/chatdbg_gdb.py")' >> ~/.gdbinit
  ```

  This will install ChatDBG as a GDB extension.
  </details>



  <details>
  <summary>
  <B><TT>WinDBG</TT> installation instructions</B>
  </summary>

  1. **Install WinDBG**: Follow instructions [here](https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/) if `WinDBG` is not installed already.
  1. **Install `vcpkg`**: Follow instructions [here](https://vcpkg.io/en/getting-started) if `vcpkg` is not installed already.
  1. **Install Debugging Tools for Windows**: Install the Windows SDK [here](https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/) and check the box `Debugging Tools for Windows`.
  1. **Navigate to the `src\chatdbg` directory**: `cd src\chatdbg`
  1. **Install needed dependencies**: Run`vcpkg install`
  1. **Build the chatdbg.dll extension**: Run`mkdir build & cd build & cmake .. & cmake --build . & cd ..`

  **Using ChatDBG**:

   * Load into WinDBGX:
     * Run `windbgx your_executable_here.exe`
     * Click the menu items `View` -> `Command browser`
     * Type `.load debug\chatdbg.dll`
   * After running code and hitting an exception / signal:
     * Type `!why` in Command browser
  </details>






  To use ChatDBG to debug Python programs, simply run your Python script as follows:

  ```bash
  chatdbg -c continue yourscript.py
  ```

  ChatDBG is an extension of the standard Python debugger `pdb`. Like
  `pdb`, when your script encounters an uncaught exception, ChatDBG will
  enter post mortem debugging mode.

  Unlike other debuggers, you can then use the `why` command to ask
  ChatDBG why your program failed and get a suggested fix.  After the LLM responds,
  you may issue additional debugging commands or continue the conversation by entering
  any other text.



  To use ChatDBG as the default debugger for IPython or inside Jupyter Notebooks,
  create a IPython profile and then add the necessary exensions on startup.  (Modify
  these lines as necessary if you already have a customized profile file.)

  ```bash
  ipython profile create
  echo "c.InteractiveShellApp.extensions = ['chatdbg.chatdbg_pdb', 'ipyflow']" >> ~/.ipython/profile_default/ipython_config.py
  ```

  On the command line, you can then run:

  ```bash
  ipython --pdb yourscript.py
  ```

  Inside Jupyter, run your notebook with the [ipyflow kernel](https://github.com/ipyflow/ipyflow) and include this line magic at the top of the file.

  ```
  %pdb
  ```




  To use ChatDBG with `lldb` or `gdb`, just run native code (compiled with `-g` for debugging symbols) with your choice of debugger; when it crashes, ask `why`. This also works for post mortem debugging (when you load a core with the `-c` option).

  The native debuggers work slightly differently than Pdb.  After the debugger responds to your question, you will enter into ChatDBG's command loop, as indicated by the `(ChatDBG chatting)` prompt.  You may continue issuing debugging commands and you may send additional messages to the LLM by starting those messages with "chat".  When you are done, type `quit` to return to the debugger's main command loop.

  <details>
  <summary>
  <B>Debugging Rust programs</B>
  </summary>

  To use ChatDBG with Rust, you need to do two steps: modify your
  `Cargo.toml` file and add one line to your source program.

  1. Add this to your `Cargo.toml` file:

  ```toml
  [dependencies]
  chatdbg = "0.6.2"

  [profile.dev]
  panic = "abort"

  [profile.release]
  panic = "abort"
  ```

  2. In your program, apply the `#[chatdbg::main]` attribute to your `main`
  function:

  ```rust

  fn main() {
  ```

  Now you can debug your Rust code with `gdb` or `lldb`.

  </details>



  <details>
  <summary>
  <B>ChatDBG example in <TT>lldb</TT></B>
  </summary>

  ```gdb
  (ChatDBG lldb) run
  Process 85494 launched: '/Users/emery/git/ChatDBG/test/a.out' (arm64)
  TEST 1
  TEST -422761288
  TEST 0
  TEST 0
  TEST 0
  TEST 0
  TEST 0
  TEST 0
  Process 85494 stopped
  * thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x100056200)
      frame #0: 0x0000000100002f64 a.out`foo(n=8, b=1) at test.cpp:7:22
     4     int x[] = { 1, 2, 3, 4, 5 };
     5
     6     void foo(int n, float b) {
  -> 7       cout << "TEST " << x[n * 10000] << endl;
     8     }
     9
     10    int main()
  Target 0: (a.out) stopped.
  ```

  Ask `why` to have ChatDBG provide a helpful explanation why this program failed, and suggest a fix:


  ```gdb
  (ChatDBG lldb) why
  The root cause of this error is accessing an index of the array `x`
  that is out of bounds. In `foo()`, the index is calculated as `n *
  10000`, which can be much larger than the size of the array `x` (which
  is only 5 elements). In the given trace, the program is trying to
  access the memory address `0x100056200`, which is outside of the range
  of allocated memory for the array `x`.

  To fix this error, we need to ensure that the index is within the
  bounds of the array. One way to do this is to check the value of `n`
  before calculating the index, and ensure that it is less than the size
  of the array divided by the size of the element. For example, we can
  modify `foo()` as follows:

      ```
      void foo(int n, float b) {
        if (n < 0 || n >= sizeof(x)/sizeof(x[0])) {
          cout << "ERROR: Invalid index" << endl;
          return;
        }
        cout << "TEST " << x[n] << endl;
      }
      ```

  This code checks if `n` is within the valid range, and prints an error
  message if it is not. If `n` is within the range, the function prints
  the value of the element at index `n` of `x`. With this modification,
  the program will avoid accessing memory outside the bounds of the
  array, and will print the expected output for valid indices.
  ```
  </details>

  <details>
  <summary>
  <B>ChatDBG example in Python (<TT>pdb</TT>)</B>
  </summary>

  ```python
  Traceback (most recent call last):
    File "yourscript.py", line 9, in <module>
      print(tryme(100))
    File "yourscript.py", line 4, in tryme
      if x / i > 2:
  ZeroDivisionError: division by zero
  Uncaught exception. Entering post mortem debugging
  Running 'cont' or 'step' will restart the program
  > yourscript.py(4)tryme()
  -> if x / i > 2:
  ```

  Ask `why` to have ChatDBG provide a helpful explanation why this program failed, and suggest a fix:

  ```python
  (ChatDBG Pdb) why
  The root cause of the error is that the code is attempting to
  divide by zero in the line "if x / i > 2". As i ranges from 0 to 99,
  it will eventually reach the value of 0, causing a ZeroDivisionError.

  A possible fix for this would be to add a check for i being equal to
  zero before performing the division. This could be done by adding an
  additional conditional statement, such as "if i == 0: continue", to
  skip over the iteration when i is zero. The updated code would look
  like this:

  def tryme(x):
      count = 0
      for i in range(100):
          if i == 0:
              continue
          if x / i > 2:
              count += 1
      return count

  if __name__ == '__main__':
      print(tryme(100))
  ```

  </details>


pkgId: 1c4daf61660569af5049fff8e51190e3eea5defa1f318fa18fb0b280af761cf2
name: python-ChatTDD
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: A utility to assist in building Test-Driven Python code using Langchain and OpenAI.
url: https://github.com/shuuse/ChatTDD
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChatTDD-0.2.10-1.src.rpm
checksum_type: sha256
description:
  ChatTDD is a utility designed to help developers create Test-Driven Python code using Langchain and OpenAI. By entering a description of the functionality you need, ChatTDD will generate code for that function based on a test.



  To install ChatTDD, ensure you have Python 3.9 installed, then run the following command:

  ```markdown
  pip install ChatTDD
  ```



  Before using ChatTDD, you'll need to have an OpenAI API key. If you don't have one, you can obtain it from [OpenAI](https://beta.openai.com/signup/). Remember, using your api key with ChatTDD or any other client will come with a cost to you - so be warned and run at your own risk.

  Update your environment with your api key:
  ```markdown
  export OPENAI_API_KEY='[your key here]'
  ```

  If a key isn't present in the environment then ChatTDD will prompt you to enter it.




  Once installed, you can use the chattdd command to interact with the tool. Here's how to use ChatTDD:


  You can choose between three models: text-davinci-003, gpt-3.5-turbo, and gpt-4.
  To select a model, use the following command:

  ```markdown
  chattdd model text-davinci-003
  ```

  Your model selection will be remembered for future sessions.



  ```markdown
  chattdd outputfolder [folder_path]
  ```
  Sets the root folder for generated files. If this is left blank, files will be saved in the specified relative paths without a leading folder.



  Simply run
  ```markdown
  chattdd
  ```
  ChatTDD will ask for your requirement.
  Alternative:

  ```markdown
  chattdd test-and-code "sort a list of objects alphabetically"
  ```

  ChatTDD will create the necessary Python files under the default directory or the directory you have setup with the 'outputfolder' command.



  ```markdown
  chattdd test "sort a list of objects alphabetically"
  ```

  ChatTDD will create the necessary Python files under the `tests` directory.



  If you'd like to contribute to the development of ChatTDD, please feel free to fork the repository and submit a pull request.



  ChatTDD is licensed under the MIT License. See the `LICENSE` file for more details.


pkgId: ce70f1c560f6cf3a993398d0c984bbc5857af531a157528a1f3ef7ab581fbad3
name: python-Chatbot-by-IE
arch: src
version: 0.2.26
epoch: 0
release: 1
summary: Chatbot: Addressbook, NoteBook, Sort file, Games
url: https://github.com/Sanyavas/chatbot-team-project.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chatbot-by-IE-0.2.26-1.src.rpm
checksum_type: sha256
description:
  ___
  Chatbot С–s a personal assistant.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

  ```bash
  pip install Chatbot-by-IE
  ```



  * AddressBook
  * NoteBook
  * Sort files
  * Games









  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 4f2f7e7459c86441a5a565b6c45f0ff97e246017bbc2ec41f80484fbfc039b53
name: python-ChatbotAPI
arch: src
version: 2.5
epoch: 0
release: 1
summary: Library to make AI chatbot with other additional utilities
url: https://github.com/hilfing/ChatbotAPI
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChatbotAPI-2.5-1.src.rpm
checksum_type: sha256
description:
   An python package to make it easier to connect to the brainshop API and make a working AI chatbot

   
   Do `py -m pip install ChatbotAPI` and you are done.

   
   There are various commands and utilities in this package.
   To use it just do
   ```
   from ChatbotAPI import ChatBot
   bot = ChatBot(BrainId, ApiKey, BotName, history, debug)
   data = bot.sendmsg("Hi")
   print(data)
   ```
   1. To get Brain Id and other info go to [BrainShop](https://brainshop.ai)
   2. Make an account
   3. Make a brain and don't change any settings
   4. Go to the settings tab and copy the BrainID and APIkey and then use it
   5. Use boolean for history and debug switch.
   6. To turn on spellchecker use `bot.spellcheck(True)`
   7. Voila! It works! Now enjoy your AI chatbot.
   Thats All


   
   AI Chatbot. Can make interesting conversations.
   Can do math.
   Can say jokes.
   Has history function and debugging with logs.
   Support multiple bot instances with different settings

   
  [Wiki](https://github.com/hilfing/ChatbotAPI/wiki/Python)

   PackageWebsite - [ChatbotAPI on Pypi](https://pypi.org/project/ChatbotAPI/)
   AuthorWebsite - [PaulStudios](https://paulstudios.great-site.net)


pkgId: 69bb3428f60bae434d5016d2bc1878f2a9d3e9741f150a2cc0225681bb28e3cd
name: python-CheckMyTex
arch: src
version: 0.10.5
epoch: 0
release: 1
summary: A simple tool for checking complex LaTeX documents, e.g., dissertations.
url: https://github.com/d-krupke/checkmytex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheckMyTex-0.10.5-1.src.rpm
checksum_type: sha256
description:
  A tool to comfortably check complex LaTeX documents, e.g., dissertations, for
  common errors. There are already pretty good correction tools for LaTex, e.g.,
  [TeXtidote](https://github.com/sylvainhalle/textidote),
  [YaLafi](https://github.com/matze-dd/YaLafi) (of which we use the tex2text
  engine), or [LaTeXBuddy](https://gitlab.com/LaTeXBuddy/LaTeXBuddy) (in which I
  was involved and of which I copied some things), but they had shortcomings with
  complex documents, and they also did not fit my workflow. CheckMyTex builds upon
  YaLafi, but provides a simple CLI with some additional magic and tricks to deal
  with hopefully any document. The primary difference to its main contenders is
  the focus on CLI and whitelists.

  > :warning: Your terminal needs to support rich (should be most terminals)!

  Primary concepts are

  - not just listing problems but also their exact locations,
  - working on the whole document, not just individual files (because otherwise,
    you forget to check some files),
  - lots of predefined rules such as newcommand-substitution, todo-removal, etc.,
  - simple extension of further checking modules,
  - ability to whitelist found problems and share this whitelist,
  - edit the errors directly (in Vim with automatic jump to line), and
  - having a single, simple command that you can easily run before every commit.

  This tool has a fancy HTML-output (like other tools), but its primary intention
  is to be used as CLI:

  1. Thanks to colored output, the highlighting works just as nice in CLI as in
     HTML. No need to switch to your browser.
  2. The CLI can use your favourite editor (currently, only (n)vim and nano have
     full support) without switching context.

  An example output can be seen
  [here](https://htmlpreview.github.io/?https://github.com/d-krupke/CheckMyTex/blob/main/example_output.html).
  The CLI version looks nearly identical (thanks to
  [rich](https://rich.readthedocs.io/en/stable/introduction.html), but you are
  iteratively asked how to deal with each problem.



  - Spelling errors using aspell or
    [pyspellchecker](https://pypi.org/project/pyspellchecker/)
  - Grammar errors using [languagetool](https://languagetool.org/)
  - LaTeX-smells using [ChkTeX](https://www.nongnu.org/chktex/)
  - Raw numbers instead of siunitx ([simple regex](checkmytex/finding/siunitx.py),
    showing you how easy new modules can be added)
  - Additional advise from [proselint](https://github.com/amperser/proselint)
  - (Correct) usage of cleveref.
  - Uniform writing style of NP-hard/complete (this is probably a problem only
    within my community, but it doesn't harm you)

  I found this set of tools to be sufficient to find most problems in text and
  LaTeX-source, and I am constantly surprised on how well it works.

  The sources are detexed before applying grammar or spelling checking using
  [YaLafi](https://github.com/matze-dd/YaLafi).

  Further checks may be added in the future. I do a lot of collaborative writing
  on papers and am constantly confronted with bad LaTeX that I try to detect
  automatically.



  You can install CheckMyTex using pip (if you have Python3 installed)

  ```
  pip install checkmytex
  ```

  You additionally need to install [languagetool](https://languagetool.org/) and a
  LaTeX-distribution (which should contain ChkTeX). To have a better spell
  checker, you should also install aspell and the corresponding dictionaries. All
  these should be available via yours systems package manages, e.g. `pacman`,
  `apt`, or `brew`.

  > :warning: This tool currently only supports Unix (Linux and Mac OS). It could
  > work in some windows configurations, but probably you get some unexpected
  > behavior due to incompatible system calls.



  ```shell
  brew install --cask mactex  # install a tex distribution
  brew install languagtool  # install the grammar checker languagetool
  brew install aspell  # install a dictionary
  ```



  ```shell
  sudo pacman -S texlive-most languagetool aspell aspell-en
  ```



  ```bash
  checkmytex main.tex
  ```

  CheckMyTex will now guide you through your document and show you all problems,
  skipping over good parts. For each problem, you will be asked what to do

  ```
  [s]kip,[S]kip all,[w]hitelist,[I]gnore all,[n]ext file,[e]dit,[l]ook up,[f]ind,[?]:
  ```

  - _skip_ will skip this concrete problem, but ask you again next time you run
    CheckMyTex.
  - _Skip all_ will skip this problem and all identical problems, but ask you
    again on the next run of CheckMyTex.
  - _whitelist_ will whitelist the problem and never ask you about it again (for
    this document).
  - _Ignore_ will ignore all problems that belong to the same rule, but ask you
    again next time you run CheckMyTex.
  - _next file_ will jump to the next file.
  - _edit_ will open you `$EDITOR` at the location of the problem. It tries to
    keep track of line changes without reprocessing the document.
  - _look up_ will google the problem for you (if available). E.g., you can check
    for rare technical terms.
  - _find_ allows to search with a regular expression for further occurrences. Use
    this, e.g., to find a uniform spelling.
  - _?_ provides further information of the problem. Primarily for debugging and
    fine-tuning.

  Whitelisted problems are by default saved in `.whitelist.txt` (document root)
  and are human-readable. You can copy it to use also for other documents or
  change the path using the `-w` argument with a path when calling CheckMyTex.

  This tool will have problems with some areas of you document. You can exclude
  these areas by adding lines with `%PAUSE-CHECKING` and `%CONTINUE-CHECKING`.
  This may be easier than whitelisting all the problems.

  The time to check a 300-page dissertation is around a few seconds. A better
  spell checking would be available but drastically increase the runtime.

  If you want to process the output with another tool, you can export the result
  as json using:

  ```bash
  checkmytex --json analysis.json main.tex
  ```

  If you want an HTML-document you can share with your co-authors, use

  ```bash
  checkmytex --html analysis.html main.tex
  ```





  CheckMyTex already comes with a set of very useful tools and rules to find
  potential problems.

  ```python
  from checkmytex.finding import (
      Languagetool,
      AspellChecker,
      CheckSpell,
      UniformNpHard,
      Cleveref,
      Proselint,
      SiUnitx,
  )
  ```

  You can also easily create your own rule. For example, a common antipattern in
  my community is to exclude many lines of text by defining a `\old{..}`-command.
  Let us quickly write a rule that detects this behavior, using a simple regular
  expression.

  Note that `LatexDocument` provides us with all the necessary tools to read
  source and compiled latex, as well as trace the problem back to its origin.

  ```python
  import re
  from checkmytex.finding import Checker, Problem
  from checkmytex import LatexDocument
  import typing


  class NoOld(Checker):
      def check(self, document: LatexDocument) -> typing.Iterable[Problem]:
          source = document.get_source()
          for match in re.finditer(r"\\old\{", source):
              origin = document.get_simplified_origin_of_source(
                  match.start(), match.end()
              )
              context = document.get_source_context(origin)
              long_id = f"NO_OLD:{context}"
              yield Problem(
                  origin,
                  "Please do not use \\old{! (it confuses highlighting)",
                  context=context,
                  long_id=long_id,
                  tool="CustomNoOld",
                  rule="NO_OLD",
              )
  ```

  This is all! Now you can add this rule to the `DocumentAnalyzer` with
  `add_checker`. You may want to copy the main.py and build yourself a custom
  version that directly includes this rule.



  Some false positives follow some pattern. For example author names are usually
  not in any dictionary. The current default already tries to detect if a spelling
  error is actually an author name and automatically removes it. You can easily
  write such a filter yourself.

  By default, CheckMyTex comes with the following filtering rules:

  - Spelling errors in `\includegraphics`-paths.
  - Spelling errors in labels.
  - Spelling errors of words used in the bibliography. This also removes a lot of
    author names from the problem list.
  - Spelling errors of author names before a `\cite`
  - Problems in the whitelist.
  - Ignore words used repeatedly in adjacent sentences (currently only the word
    "problem").
  - Words with `\` or `$` in them. They are usually terms and not proper words.

  Let us extend these rules: imagine you don't want any errors within an
  align-environment shown.

  ```python
  import re
  import typing

  from checkmytex.filtering import Filter
  from checkmytex.finding import Problem
  from checkmytex import LatexDocument


  class FilterAlign(Filter):
      def __init__(self):
          self._ranges = []

      def prepare(self, document: LatexDocument):
          
          expr = r"\\begin\{align\}.*?\\end\{align\}"
          source = document.get_source()
          for match in re.finditer(expr, source, re.MULTILINE | re.DOTALL):
              self._ranges.append((match.start(), match.end()))

      def filter(self, problems: typing.Iterable[Problem]) -> typing.Iterable[Problem]:
          for p in problems:
              s_span = p.origin.get_source_span()
              if any(r[0] <= s_span[0] < r[1] for r in self._ranges):
                  continue  # problem starts within a previous found range of an align-environment
              yield p
  ```

  We can add this filter similar to a checker to the `DocumentAnalyzer`.



  Other languages are partially supported: You need to create your own main-file
  and provide the right language codes for the different tools. An example for
  german can be found in [german.py](./examples/german.py).



  This tool is still under development but already usable. Just expect some
  imperfections. Ideas are welcome.



  - Reduce double-whitespace matches. They do not matter in LaTeX. Maybe clean the
    detexed file instead of just disabling the corresponding rules?
  - More configuration options. Currently, the best option is to simply build your
    own [main.py](./checkmytex/__main__.py)



  - 0.10.5: Fixing `--print` option.
  - 0.10.4: Fixing exception when $EDITOR is not set.
  - 0.10.3: Making project slightly more robust.
  - 0.10.2: Making project pep compliant.
  - 0.10.1: Also the interactive mode is now using rich.
  - 0.10.0: Beautiful HTML-output using _rich_. Interactive CLI will follow soon.
  - 0.9.0: Fundamental refactoring and JSON-ouput.
  - 0.8.1: Fixing problem with text manipulated by commands. All found errors now
    should only span a single line. Solution is ugly and should be improved. For
    now, it is working. .


pkgId: 25cc966cd60e166437d7970e627d8e885a85ad1c6401c9dff2cf14bf9ba78ce4
name: python-CheckmarxPythonSDK
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Checkmarx Python SDK
url: https://github.com/checkmarx-ts/checkmarx-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheckmarxPythonSDK-1.0.4-1.src.rpm
checksum_type: sha256
description:
  This is wrapper using Python for CxSAST and CxOSA REST API, Portal SOAP API, CxSAST ODATA API, CxSCA REST API.

  By using this SDK, Checkmarx users will be able to do automatic scanning with CxSAST, CxOSA, and CxSCA.

  [![Downloads](https://static.pepy.tech/badge/CheckmarxPythonSDK/month)](https://static.pepy.tech/badge/CheckmarxPythonSDK/month)
  [![Supported Versions](https://img.shields.io/pypi/pyversions/CheckmarxPythonSDK.svg)](https://pypi.org/project/CheckmarxPythonSDK)
  [![Contributors](https://img.shields.io/github/contributors/checkmarx-ts/checkmarx-python-sdk.svg)](https://github.com/checkmarx-ts/checkmarx-python-sdk/graphs/contributors)



  For more information about Checkmarx API, please refer to Checkmarx knowledge Center：

  - [CxSAST API Document](https://checkmarx.com/resource/documents/en/34965-46552-sast-api-guide.html)
  - [CxOSA API Document](https://checkmarx.com/resource/documents/en/34965-46909-cxosa-api-guide.html)
  - [Access Control API Document](https://checkmarx.com/resource/documents/en/34965-46622-access-control--rest--api--v1-5-and-up-.html)
  - [CxSCA API Document](https://checkmarx.com/resource/documents/en/34965-19221-checkmarx-sca--rest--api-documentation.html)
  - [CxOne API Document](https://checkmarx.com/resource/documents/en/34965-68772-checkmarx-one-api-documentation.html)
  - [CxReporting API Document](https://checkmarx.com/resource/documents/en/34965-93162-apis.html)



  Please use Python3





  The easiest way to begin using the SDK is to install it using the **pip** command.

  ```
  $ pip install CheckmarxPythonSDK
  ```

  Alternatively, either download and unzip this repository, or clone it to your local drive, and install using the `setup.py` script.

  ```
  $ git clone https://github.com/checkmarx-ts/checkmarx-python-sdk.git
  $ python setup.py install
  ```

  Even if you install the SDK using **pip**, you might still want to download or clone this repository for the sample scripts.




  ```buildoutcfg
  [checkmarx]
  base_url = http://localhost:80
  username = ******
  password = ******
  grant_type = password
  scope = sast_rest_api
  client_id = resource_owner_client
  client_secret = 014DF517-39D1-4453-B7B3-9930C563627C
  url =  s/cxrestapi
  scan_preset = Checkmarx Default
  configuration = Default Configuration
  team_full_name = /CxServer
  max_try = 3

  [CxSCA]
  access_control_url = https://platform.checkmarx.net
  server = https://api-sca.checkmarx.net
  account = ***
  username = ***
  password = ***

  [CxOne]
  access_control_url = https://iam.checkmarx.net
  server = https://ast.checkmarx.net
  tenant_name  = ***
  grant_type = refresh_token
  client_id = ast-app
  client_secret = ***
  username = ***
  password = ***
  refresh_token = ***

  [CxReporting]
  base_url = http://localhost
  reporting_client_url = http://localhost:5001
  username = ***
  password = ***
  grant_type = password
  scope = reporting_api
  client_id = reporting_service_api
  client_secret = 014DF517-39D1-4453-B7B3-9930C563627C
  ```

  configuration file path:

  By default, Checkmarx Python SDK looks for `config.ini` or `config.json` file in a `.Checkmarx` folder in your home directory.
  - For windows, it should be like `C:\\Users\\<UserName>\\.Checkmarx\\config.ini`
  - For linux and MacOS, it should be like `/home/<UserName>/.Checkmarx/config.ini`

  You can also use `checkmarx_config_path` as environment variable  or command line argument to set up configuration file path.

  For CxOne configuration, if you are going to use refresh_token grant type, you must use client id "ast-app",
  refresh_token, ignore client_secret, username, password. If you are going to use client_credentials grant type,
  you must create a client with roles such as ast-scanner, manage-webhook, queries-editor, ast-viewer, manage-application,
  manage-project, then fill in your own client_id, client secret, username, password, ignore the refresh_token.



  For CxSAST:

      - cxsast_base_url
      - cxsast_username
      - cxsast_password
      - cxsast_grant_type
      - cxsast_scope
      - cxsast_client_id
      - cxsast_client_secret

  For CxSCA:

      - cxsca_access_control_url
      - cxsca_server
      - cxsca_account
      - cxsca_username
      - cxsca_password

  For CxOne:

      - cxone_access_control_url
      - cxone_server
      - cxone_tenant_name
      - cxone_grant_type
      - cxone_client_id
      - cxone_client_secret
      - cxone_username
      - cxone_password
      - cxone_refresh_token

   For CxReporting

      - cxreporting_base_url
      - cxreporting_reporting_client_url
      - cxreporting_username
      - cxreporting_password
      - cxreporting_grant_type
      - cxreporting_scope
      - cxreporting_client_id
      - cxreporting_client_secret


  You can use command line option `--cx_debug true` to enable debug mode. In debug mode, it will print out how to load the
  configuration file and print every http request send out.


   Please find example scripts from [examples folder](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/examples).




  - [CxOne_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxOne_REST_API_List.md)
  - [CxSAST_and_CxOSA_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_and_CxOSA_REST_API_List.md)
  - [CxSAST_ODATA_API](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_ODATA_API.md)
  - [CxSAST_Portal_SOAP_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_Portal_SOAP_API_List.md)
  - [CxSCA_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSCA_REST_API_List.md)
  - [CxReporting_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/blob/master/docs/CxReporting_REST_API_List.md)


pkgId: df4c85c0ea03e3fbb00c3f005aaff849f322cead9cb9062df403904b4587542b
name: python-CheckmateSample
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: A sample project with checkerboard functionality
url: https://github.com/ThomasMGeo/CheckmateSample
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheckmateSample-0.2.13-1.src.rpm
checksum_type: sha256
description:
  This Python module provides a function to generate a checkerboard pattern using NumPy. The function make_checkerboard creates a 2D NumPy array representing a checkerboard with customizable board size and square (and rectangle) sizes. Can be used for geospatial ML problems to try and combat autocorrelation. The functions can export two (testing/training) and three (testing/training/validation) checkerboard patterns




  board_size (tuple[int, int]): Size of the board in (rows, columns).

  square_size (tuple[int, int]): Size of each square in (rows, columns).

  validation (bool): If True, use a ternary (0, 1, 2) pattern; if False, use a binary (0, 1) pattern

  xarray only:

  dim_names (dict): Dictionary specifying the names of x and y dimensions
  da (xr.DataArray): Input DataArray to apply the checkerboard pattern to



  numpy and xarray




  checkerboard = make_checkerboard((10, 10), (2, 2))


  da = xr.DataArray(np.random.rand(100, 100), dims=['lat', 'lon'])


  result = make_checkerboard_xr(da, (10, 10), keep_pattern=1)


pkgId: ed31335b0cc59de98a35b98d56e72478a32cd1395727cd92b92d066653c885eb
name: python-CheckmateSample
arch: src
version: 0.3.2.post0
epoch: 0
release: 1
summary: A sample project with checkerboard functionality
url: https://github.com/ThomasMGeo/CheckmateSample
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheckmateSample-0.3.2.post0-1.src.rpm
checksum_type: sha256
description:
  This Python module provides a function to generate a checkerboard pattern using NumPy. The function make_checkerboard creates a 2D NumPy array representing a checkerboard with customizable board size and square (and rectangle) sizes. Can be used for geospatial ML problems to try and combat autocorrelation. The functions can export two (testing/training) and three (testing/training/validation) checkerboard patterns




  board_size (tuple[int, int]): Size of the board in (rows, columns).

  square_size (tuple[int, int]): Size of each square in (rows, columns).

  separation_size (int): Size of separation distance in pixels between squares.

  validation (bool): If True, use a ternary (0, 1, 2) pattern; if False, use a binary (0, 1) pattern

  an example of this is:

  ```
  checkerboard_01 = make_checkerboard(board_size=(70,70), square_size=(10,10), separation_size=2)
  ```

  xarray only:

  dim_names (dict): Dictionary specifying the names of x and y dimensions
  da (xr.DataArray): Input DataArray to apply the checkerboard pattern to

  an example of this:


  ```
  ds = xr.tutorial.load_dataset('air_temperature')

  air_temp = ds.air.isel(time=0)

  square_size = (7, 5)  # 7x5 pixel squares
  checkerboard_temp_0 = make_checkerboard_xr(air_temp, square_size, separation_size=3, keep_pattern=0, validation=False)
  ```



  numpy and xarray




  checkerboard = make_checkerboard((10, 10), (2, 2))


  da = xr.DataArray(np.random.rand(100, 100), dims=['lat', 'lon'])


  result = make_checkerboard_xr(da, (10, 10), keep_pattern=1)


pkgId: 80a4f4107fa0f0f8b430b308894d1c322b9241e1f7d3b6d90eb804cf8a6c62b5
name: python-CheckstyleBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CheckstyleBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CheckstyleBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheckstyleBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Check Java code for possible style, semantic and design issues.

      For more information, consult
      <http://checkstyle.sourceforge.net/checks.html>.


pkgId: 2a7940a10f01f8103fc2987e123ba52f04a9e008bb9942b1a35dd10e88c55afb
name: python-CheeseAPI
arch: src
version: 1.6.22
epoch: 0
release: 1
summary: 一款web协程框架
url: https://pypi.org/project/CheeseAPI/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheeseAPI-1.6.22-1.src.rpm
checksum_type: sha256
description:
  一款协程友好的web框架，它具有以下功能：

  1. 插件支持，更可塑的事件处理以及个性化设置

  2. 以模块为主的项目结构，以及灵活的模块导入方式

  3. Websocket支持



  系统要求：Unix，例如Linux、Mac等；不支持Windows，若有需要请使用Windows的WSL运行程序

  ```
  pip install CheeseAPI
  ```



  1. **[CheeseLog](https://github.com/CheeseUnknown/CheeseLog)**

  日志系统，CheeseAPI使用它进行日志的输出与记录



  CheeseAPI采用模块结构：

  ```
  | - User
      | - __init__.py
      | - model.py
      | - api.py
      | - service.py
      | - handle.py
      | - validator.py
  | - Permission
      | - __init__.py
      | - model.py
      | - api.py
      | - service.py
      | - validator.py
  | - __init__.py
  | - app.py
  ```

  CheeseAPI并没有强制规定文件名，但建议的文件命名方式如下：

  | 文件名 | 备注 |
  | - | - |
  | \_\_init\_\_.py | 公用变量 |
  | model.py | ORM或类 |
  | api.py | API接口 |
  | service.py | 业务逻辑实现 |
  | handle.py | 插槽逻辑 |
  | validator.py | 参数校验 |

  一般来说，模块中的文件调用有明显的顺序关系（从顶层到底层）：

  ```
  handle.py --|
              |-> service.py -> model.py -> __init__.py
  api.py -----|
              |-> validator.py
  ```



  创建一个启动入口文件`app.py`：

  ```python
  from CheeseAPI import app, Response

  @app.route.get('/')
  async def index(**kwargs):
      return Response('这里是CheeseAPI！')

  app.run()
  ```

  运行`app.py`，可以看到打印了一些服务器的基本信息：

  ```
  $ python app.py
  (STARTING) 2024-03-19 14:03:12.405969 > The master process 346 started
  (STARTING) 2024-03-19 14:03:12.406156 > Workspace Information:
      Base: /home/cheese/Code/CheeseAPI
      Static: ./static/
  (STARTING) 2024-03-19 14:03:12.406235 > Server Information:
      Host: 0.0.0.0
      Port: 5214
      Workers: 1
      Backlog: 1024
      Static: /
  (LOADED) 2024-03-19 14:03:12.418829 > Local Modules:
      CheeseAPI
  (DEBUG) 2024-03-19 14:03:12.418939 > The process 346 started
  (STARTING) 2024-03-19 14:03:12.419363 > The server started on 0.0.0.0:5214
  ```

  出现`The process xxx started`日志时，代表其中某个worker已启动，此时已经可以进行网络请求访问；出现`The server started on 0.0.0.0:5214`日志时，代表服务器已完全启动

  使用`ctrl + c`或`kill`命令杀死主进程，会输出结束日志，此时整个程序才算正式关闭：

  ```
  (DEBUG) 2024-03-19 14:05:40.350681 > The process 346 stopped
  (ENDING) 2024-03-19 14:05:40.350816 > The server runs for a total of 2 minutes 27.944854 seconds
  (ENDING) 2024-03-19 14:05:40.350849 > The master process 346 stopped
  ```









































  websocket的升级插件，支持了更多、更便捷的通讯方式


pkgId: 4d2d74e34da6d3442b44d2c6c93b74b1c056a1dff6606255a0aeb81c4325fc53
name: python-CheeseFramework
arch: src
version: 1.4.95
epoch: 0
release: 1
summary: Framework for creating web applications
url: https://github.com/KubaBoi/CheeseFramework/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CheeseFramework-1.4.95-1.src.rpm
checksum_type: sha256
description:
  <a href="https://kubaboi.github.io/CheeseFramework/">
  <img align="right" width=150 height=150 src="https://kubaboi.github.io/CheeseFramework/documentation/documentation300x300.png">
  </a>



  [![Release Build](https://github.com/KubaBoi/CheeseFramework/actions/workflows/realeaseDate.yml/badge.svg?branch=main)](https://github.com/KubaBoi/CheeseFramework/actions/workflows/realeaseDate.yml)



  Test version v(1.4.95) - 23.08.18.18.40



  - [x] autocommit
  - [x] models and autocommits
  - [x] javascript



   https://github.com/KubaBoi/CheeseFramework/tree/development



  It is same as this BUT it is formated by my own algorithm into html. So contents is fixed on the left side of screen and it is overall clearer. (In my opinion...) Check it out :wink: it was a really hard work. All source codes are in branch `webServices` in directory ./mdConverter. I would be honored if it would help you. :relieved:

  https://kubaboi.github.io/CheeseFramework/

  <a href="https://kubaboi.github.io/CheeseFramework/doc.html" target="_blank">Complete method and classes documentation</a>



   - [Introduction](#1-introduction)
      -  [Installation](#11-instalation)
          - [Downloads](#111-downloads)
          - [Creating new project](#112-creating-new-project)
          - [Run Cheese application](#113-run-cheese-application)
   - [Cheese Tools](#2-cheese-tools)
   - [Build](#3-build)
      - [Metadata](#31-metadata)
   - [Project structure](#4-project-structure)
      - [/resources](#41-resources)
      - [/src](#42-src)
      - [/web](#43-web)
      - [/*.json files](#44-json-files)
   - [Configuration](#5-configuration)
      - [adminSettings.json](#51-adminsettingsjson)
      - [appSettings.json](#52-appsettingsjson)
      - [securitySettings.json](#53-securitysettingsjson)
          - [authentication](#531-authentication)
          - [roles](#532-roles)
          - [access](#533-access)
          - [Authorization process](#534-authorization-process)
      - [secrets.json](#54-secretsjson)
   - [Annotations](#6-annotations)
   - [Python code](#7-python-code)
      - [API Controllers](#71-api-controllers)
          - [Create controller](#711-create-controller)
          - [Methods of controller](#712-methods-of-controller)
          - [Method arguments](#713-method-arguments)
          - [Example controller](#714-example-controller)
          - [CheeseController methods](#715-cheesecontroller-methods)
      - [Repositories](#72-repositories)
          - [Create repository](#721-create-repository)
          - [Methods of repository](#722-methods-of-repository)
              - [#@query](#7221-query)
              - [#@commit](#7222-commit)
          - [Passing arguments to SQL query](#723-passing-arguments-to-sql-query)
              - [Passing model](#7231-passing-model)
          - [Prebuilded methods](#724-prebuilded-methods)
      - [Models](#73-models)
          - [CheeseModel methods](#731-cheesemodel-methods)
              - [toJson()](#7311-tojson)
              - [toModel(jsn)](#7312-tomodeljsn)
              - [setAttrs(**attrs)](#7313-setattrsattrs)
          - [Creating model](#732-creating-model)
   - [Testing](#8-testing)
      - [Cheese test modules](#81-cheese-test-modules)
          - [UnitTest](#811-unittest)
          - [Pointer](#812-pointer)
          - [Mock](#813-mock)
      - [Creating test file](#82-creating-test-file)
      - [Test method](#83-test-method)
      - [Test examples](#84-test-examples)
   - [JavaScript](#9-javascript)
      - [autocomplete](#91-autocomplete)
      - [cookies](#92-cookies)
      - [communication](#93-communication)
      - [elementManager](#94-elementmanager)
      - [tableBuilder](#95-tablebuilder)
      - [alerts](#96-alerts)
      - [loadPage](#97-loadpage)
      - [time](#98-time)



  Cheese Framework is open source library for creating web applications with database connection (like Spring in Java). It can save a lot of time because developer does not have to making http server or creating whole database reader. Cheese is using pydobc library for database access so it is able to connect to most of modern database engines.



  Cheese Framework is using basic http python server. So DO NOT RUN outside firewall. If you are creating an application for bigger audience or you care about security use any other framework like Django and server for production like Apache or Tomcat.

  Stay safe :heart:

  I am using Tomcat like some kind of gate which listens at 80 public port and resends requests to Cheese Applications running under firewall and listen at closed to public ports.





  First of all you need to install <a href="https://pypi.org/project/CheeseFramework/">CheeseFramework from pypi.org</a>

  `pip install CheeseFramework`

  And you will need some more pypi packages:
  - `pip install pyodbc` <a href="https://pypi.org/project/pyodbc/">Documentation</a>
  - `pip install psycopg2-binary` <a href="https://pypi.org/project/psycopg2/">Documentation</a>
  - `pip install psycopg2` <a href="https://pypi.org/project/psycopg2/">Documentation</a>
  - `pip install bs4` <a href="https://pypi.org/project/beautifulsoup4/">Documentation</a>
  - `pip install requests` <a href="https://pypi.org/project/requests/">Documentation</a>
  - `pip install GitPython` <a href="https://pypi.org/project/GitPython/">Documentation</a>



  Cheese has prepared template project in git branch template. I recommend to use this tool Cheeser for generating new project.

  1. Create directory for your project
  2. Open command line in this directory:
      ```bash
      python -m Cheese -g
      ```

      or

      ```bash
      python -m Cheese -G
      ```

      - if `-g` than generator would remove HelloWorld files like ("HelloWorldController.py", "helloRepository.py")
      - I recommend to use `-G` when you are creating your first application so you can better understand how does it work.

  If you need help with Cheese commands use `python -m Cheese -h`.

  That's all now you can start your application :blush:



  Main script of Cheese applications is located in directory `<your project>/src/<your project>.py`
  So just run this script.

  <img src="https://kubaboi.github.io/CheeseFramework/documentation/images/firstRun.png">

  Default app port is `8000` so you can check if everything works at <a href="http://localhost:8000">localhost:8000</a>

  Congratulation :clap: you are now Dairy developer :clap:



  WIP :nail_care:



  Build is proccess which generates `.metadata` for your application. Build runs at start of application (it is pretty fast) if is in debug mode.



  `.metadata` is actually `json` but it is coded with your `key`. `key` is storred in file `./secretPass` just like regular string, nothing else. Only one string nothing more.

  This file should be ignored in `.gitignore` so during deploy you need create it in deploy app enviroment (developing on windows -> deploy on linux server) because if you would leave it in git repository, it would lose that secret point. `key` is just password for your application.

  If the `secretPass` file is missing Cheese will try for coding and decoding `Default` as a key. But it will give you call that you should use different `key`.

  In `.metadata` is storred everything except `appSettings.json` . So `adminSettings.json` , `securitySettings.json` and `secrets.json` .

  Uncoded metadata are accessible via `Metadata` class.

  ```python
  import json
  from Cheese.cheese import CheeseBurger
  from Cheese.metadata import Metadata

  CheeseBurger.init()

  pathToCodedFile = "some\\path\\.metadata"
  key = "jauukfnd" # key to decode data

  with open(pathToCodedFile, "r", encoding="utf-8") as f:
      rawData = f.read() # loads data from file coded base64

  codedData = Metadata.decode64(rawData) # decode base64
  rawJsonData = Metadata.decode(codedData, key) # decode by your key
  jsonData = json.loads(rawJsonData) # loads json from string into dictionary

  with open("metadata.json", "w") as f:
      f.write(json.dumps(jsonData))
  ```

  Or since v(1.4.80) there is a tool for decoding metadata:

  ```bash
  python -m Cheese -m "key"
  ```

  This will generate `metadata.json` file in `root` directory of project.



  In this paragraph we will talk about directories generated by Cheeser. I should tell you that there is class `ResMan` in Cheese. `ResMan` mediates paths to main directories of project. More about `ResMan` later.



  Directory where belongs all non source code files which won't be served by server. Some kind of your own settings or whatever.



  Python source code directory. Cheese will be searching there for `controllers` and `repositories` during building your application. You do not have to follow any structure. If .py file is in /src, it WILL be found by the builder.



  Directory with files served by server. Cheese server automatically looks into this directory while cannot match url endpoint with controllers.
  - If url endpoint is `"/"` it search for `/web/index.html`
  - If cannot find the file than serves `/web/errors/error404.html`
  - If `/web/errors/error404.html` is missing than returns ERROR 500



  Those files in root of your project are configuration files.



  All configration is set in `*.json` files in root of project.



  Contains only list of credentials for admin access.

  Default `adminSettings.json`

  ```json
  {
      "adminUsers":[
          {
              "name": "admin",
              "password": "admin"
          }
      ]
  }
  ```



  Contains app configuration.

  - name - Name of your application
  - version - Version of your application
  - licenseCode
      - can be left empty
      - it will affect if there will be `Powered by Cheese Framework` watermark at the right bottom corner of html pages served by Cheese server
      - if you want to get rid of this watermark go on this url http://frogie.cz:6969/licence/generate?type=full%20access and from `{ "LICENSE": { "CODE": code, "ID": int, "TYPE": "full access" } }` copy `code`
  - port - port of your app
  - dbDriver - driver for database
      - postgres - for postgresql database
      - https://github.com/mkleehammer/pyodbc/wiki  - for other databases
      - other database engines does not work very well so just use postgres please
  - dbHost - host of your database
  - dbName - name of your database
  - dbUser - user of database
  - dbPassword - password of user
  - dbPort - port of your database
  - allowDebug - If `false` application should be deployed. Logger will log only errors `"silence"=False` logs. More about logging later.
  - allowCommit - If `false` application won't commit anything into database even if you write commit query
  - allowMultiThreading - If `true` Cheese server would be able to server more request at once (I have tested that about 60 request at once is alright)
  - allowCORS - If `true` Cheese server would be able to practice CORS.
      - <a href="https://en.wikipedia.org/wiki/Cross-origin_resource_sharing">Learn about CORS</a>
      - BTW... without this it does not work (yet) :scream_cat:
  - allowDB - If `false` Cheese won't try to connect database



  In this file can be defined access to your application. There need to be 3 objects in this json `authentication` , `roles` and `access` .



  `authentication` needs two variables inside. `enabled` and `types` . `enabled` is a boolean and it tells to Cheese if you want to authenticate requests or not. `types` is an array of some ... something... you will see.

  Example of `authentication`

  ```json
  {
      "authentication": {
          "enabled": true,
          "types": [
              {
                  "patern": "(?P&lt;login&gt;\w+):(?P&lt;password&gt;\w+)", // regular expression for authentication header (for example "Joe:heslo12")
                  "validation": "select * from passwords where password = $password$ and login = $login$", // this sql will validate if validation is possible (if there is any case)
                  "roleId": "select role_id from users where login = $login$", // founds users role id after validation
                  // encoders are for decoding data from database
                  // in this example every instance of "password" will be
                  // decoded by "passKey" which is save as secret in ./secrets.js
                  "encoders": {
                      "password": "passKey"
                  },
                  // additional is list of more checks
                  "additional": [
                      // this one will check if user with $login$ exists
                      // and if not ( ! means negation) it will call http request
                      // "http://localhost:port/machines/logMachine" defined by "endpoint"
                      // with POST method defined by "method"
                      // and with POST body
                      // {
                      //      "ip": $client_ip$,
                      //      "login": $login$
                      // }
                      //
                      // This endpoint registers machine into database
                      // $client_ip$ is defined as client ip address
                      // same is defined $headers$ which are requests headers
                      {
                          "validation": "!select * from users where login = $login$",
                          "exceptions": {
                              "endpoint": "/machines/logMachine",
                              "method": "POST",
                              "content": {
                                  "ip": "$client_ip$",
                                  "login": "$login$"
                              }
                          }
                      },
                      // this example uses "raise" which will raise Unauthorized exception
                      // (with text defined in "raise")
                      // if users account with $login$ is disabled
                      {
                          "validation": "select * from users where users.login = $login$ and users.enabled = true",
                          "raise": "Your account is disabled :/"
                      },
                      // and last example
                      // you can use "exceptions" and "raise" nodes in same time
                      // if user exists but he is trying to connect from
                      // unknown machine it will raise an exception
                      // and calls "/emails/unknownMachine" endpoint
                      // which in this case would send an email to the user
                      {
                          "validation": "select * from users inner join machines on users.id = machines.user_id where users.login = $login$ and machines.ip = $client_ip$ and machines.verified = true",
                          "raise": "This machine is not registered or verified. Check your email so we know that's you. Your account is temporary disabled.<br>Sorry",
                          "exceptions": {
                              "endpoint": "/emails/unknownMachine",
                              "method": "POST",
                              "content": {
                                  "headers": "$headers$",
                                  "ip": "$client_ip$",
                                  "login": "$login$"
                              }
                          }
                      }
                  ]
              }
          ]
      }
  }
  ```



  Roles are defined with `value` and `name` . Name of role field coresponds with value returned from database via `roleId` sql request.

  Example of `roles`

  ```json
  {
      "roles": {
              "0": { // name of field fits value of roleId from database
                  "value": 0,
                  "name": "Admin"
              },
              "1": {
                  "value": 1,
                  "name": "Organiser"
              },
              "2": {
                  "value": 2,
                  "name": "Client"
              }
      }
  }
  ```



  Access is dictionary of endpoints and their minimal role value which is need to be accesible. If you have more endpoints which starts with same prefix and have same role level you can use `*` keyword and Cheese will complete them for you. And if you will use `*` but there will be some endpoints with diferent level, just add them.

  Example of `access`

  ```json
  {
      "access": {
          "/users/login": {
              "minRoleId": 2
          },
          "/users/get": {
              "minRoleId": 2
          },
          "/clubs/*": { // all endpoints starting with /clubs will have minimal role level 1
              "minRoleId": 1
          },
          "/clubs/getAll": { //except for this one... this endpoint will have minimal role level 2
              "minRoleId": 2
          }
      }
  }
  ```



  Ok ... this may looks little confusing. But it is actually pretty simple. This is process of authorization:

  - first of all is checked if authorization is even enabled - if not -> skipping
  - decode `Authorization` header from request
  - find if decoded header fits any of `paterns` from `types`
      -  `patern` is regular expression
      -  more about regular expresions https://docs.python.org/3/howto/regex.html
  - validation of credentials with `validation`
      - sql in this part needs to return anything (not empty response)
      - for example above would finall sql looks like this:
      ```sql
      select case when exists
          (select * from passwords
          where password = 'heslo12' and login = 'Joe')
      then cast(1 as bit)
      else cast(0 as bit) end
      ```
      - variables from `Authorization` header need to have same name as in `patern` and need to be wrapped in `$$` characters
  - if credentials (and every additional check) are valid it will try to find role id via `roleId` sql
      - `roleId` sql just finds value from database
      - than use this value as key for `roles` dictionary
  - endpoint validation
      - `endpoint` will be used as key for `access` dictionary
          - if `endpoint` does not exist in `access` than it will returns found `role` (it means `AUTHORIZED`)
          - if `endpoint` exists in `access` and its `minRoleId` is equal or lower then `roleId` . `value` returns `role` (`AUTHORIZED`)
          - if `endpoint` exists in `access` but its `minRoleId` is greater then `roleId` . `value` returns `False` (`UNAUTHORIZED`)
          - if `endpoint` exists in `access` but `role` is `None` returns `False` (`UNAUTHORIZED`)



  Secrets are variables which you do not want to show public in git repository or whatever. You can use `secrets.json` for storring any sensitive data. Those data will be coded into `metadata` during build and you do not need to commit them public.

  Example of storring secrets:

  ```json
  {
      "databasePassword": "sdjfgnskjdng4",
      "sizeOfMyPP": "extreme"
  }
  ```

  And in `appSettings.json` just insert its name with `$` prefix:

  ```json
  {
      "bla": "bla",
      "blabla": "blo",
      "dbPass": "$databasePassword",
      "ppMeter": "$sizeOfMyPP"
  }
  ```



  Annotations are necessary for Cheese. Cheese recognize annotation that starts `#@` and it needs to end with `;`. Yes it is just python comment and what?
  ```
  "If it is stupid but it works, it isn't stupid"
                                              Some Smart Guy - 1456
  ```

  There is a list of all annotations:

  - `#@controller`
  - `#@repository`
  - `#@post`
  - `#@get`
  - `#@query`
  - `#@commit`
  - `#@return`
  - `#@dbscheme`
  - `#@dbmodel`
  - `#@testclass`
  - `#@test`
  - `#@ignore`



  This will be about how to write `controllers` and `repositories` .



  Controllers are classes that handle requested endpoints. I recommend to create one folder just for your controllers but it is not necessary (or use the generated one ofc).

  There is documentation of `CheeseController` class https://kubaboi.github.io/CheeseFramework/doc.html#5-cheesecontroller



  As I said, controllers are classes. So create class that inherits from CheeseController.

  To let cheeser know that this class is really controller you have to anotate it with `#@controller` annotation. `#@controller` annotation follows part of endpoint like this:

  ```python

  class apiController(CheeseController):
  ```



  There is sctrict scheme how should method in controller looks so it can handle endpoint. Method has to be static, so add `@staticmethod` annotation above method definition. Method has to be anotated. Annotation for endpoints contains HTTP method (right now only `GET` and `POST`) and endpoint. Method has to have 3 arguments: `server`, `path`, `auth`.

  ```python

  @staticmethod
  def getFiles(server, path, auth):
  ```

  Every method needs to return object created via `CheeseController.createResponse()`. We will talk about `CheeseController` methods later.

  If your method solves content and headers itself you can return `CheeseNone()` object.



  Those arguments are passed by server handler.

  `server` is instance of server handler ( `BaseHTTPRequestHandler` ).

  `path` is string variable and it contains `url` without host and port. So for url `http://localhost:8000/hello/world?name=helloboi` the `path` will looks like this `/hello/world?name=helloboi` .

  `auth` is object defined during Authentication. It will looks like this:

  ```json
  {
      // role node is defined in ./securitySettings
      "role": {
          "value": 0,
          "name": "Admin"
      },
      "login": {
          "login": "login",
          "password": "password" // this will be probably removed
      },
      "userData": "tuple" // this is tuple of user's data from database (user's whole row)
  }
  ```



  Now you know almost everything you need to know to create your own controller. There are some functions that was not described yet. Those will be of course later.
  Controller will handle two endpoints:

  `/calculator/sum`

  `/calculator/sub`

  ```python



  from cheese.modules.cheeseController import CheeseController as cc


  class CalculatorController(cc):

      """
      sum two numbers in request body and return result
      body looks for example like this:
      {
      "NUM1": 1,
      "NUM2": 5
      }
      so result will looks like this:
      {
      "RESPONSE": 6
      }
      """
      
      @staticmethod
      def sum(server, path, auth):

          
          args = cc.readArgs(server)

          
          num1 = int(args["NUM1"])
          num2 = int(args["NUM2"])

          result = num1 + num2

          return cc.createResponse({"RESPONSE": result}, 200)

      """
      substract two numbers in request path and return result

      path looks for example like this:
      localhost:8000/calculator/sub?num1=5&num2=3

      so result will looks like this:
      {
      "RESPONSE": 2
      }
      """
      
      @staticmethod
      def sub(server, path, auth):

          
          args = cc.getArgs(server)

          
          num1 = int(args["num1"])
          num2 = int(args["num2"])

          result = num1 - num2

          return cc.createResponse({"RESPONSE": result}, 200)
  ```



  Repository is like access into one table of database. There are methods that communicate with database.



  Repositories are most complex part of Cheese Framework. They are again classes but there need to be more annotations. Also repository have to inherits from `CheeseRepository`

  First annotation is `#@repository`, so cheeser knows this is repository, followed by name of table.

  Second annotation is `#@dbscheme` followed by name of table's columns in brackets where first should be `Primary Key` .

  Last annotation is `#@dbmodel` followed by name of model for the table. It is just name for your better identification of model. But it is neccessary to be there.

  ```python
  from cheese.modules.cheeseRepository import CheeseRepository




  class UserRepository(CheeseRepository):
  ```



  Method scheme is again very strict. They need to be static and every method needs to have this line in it's body:

  ```python
  return CheeseRepository.query(argName1=arg1, argName2=arg2,...)
  ```

  `arg1` and `arg2` are method's arguments. Those argument's names need to corespond to names in sql annotation.

  There are two types of SQL query annotations query and commit.



  This annotation says that we want to get data from database. It is followed by SQL query. This query can be more than one line but have to be in quotation marks and the query can ends with semicolon.

  More line query:
  ```python


  ```

  With `#@query` annotation is related annotation `#@return`. It determines type of return. if annotation `#@return` is missing it is default.

  - DEFAULT - Returns raw data what get from database. Mostly it is tuple of tuples.
  ```python

  ```

  - Returns array of models.
  ```python

  ```

  - Returns only one model. If there is more results returns first.
  ```python

  ```

  - Returns logical value.
  ```python

  ```

  `#@return bool` example:

  ```python





  ```

  - Returns numeric value.
  ```python

  ```

  `#@return num` example:

  ```python


  ```



  This annotation is for writing data into database.

  ```python

  ```

  You will need it only when you want to change Primary Key of some row because there are three prebuilded methods that you should add into your repository. Those methods does not have any annotation and accepts only models. The update and delete method search rows by Primary Key so if you want to update row's Primary Key you need to write your own SQL query. (Maybe will be depreated idk)



  Arguments can be insert into SQL query if you marks them with `:` and in `return CheeseRepository.query()` name them same as in SQL query.

  Example:

  ```python


  @staticmethod
  def findByIdAndName(id, name):
      return CheeseRepository.query(someId=id, someName=name)
  ```



  If you want to pass an model it is possible.

  For model `Hello` with attributes `id=0`, `name="hello"`, `greet="hello boi"` (this is prebuilded method save):

  ```python

  @staticmethod
  def save(model):
      return CheeseRepository.query(someModel=model)
  ```

  So the finall query which will be send to database looks like this:

  ```sql
  insert into table values (0, 'first hello', 'hello boi');
  ```

  And if you want to pass only some attribute of model do this:

  ```python


  @staticmethod
  def findBy(model):
      return CheeseRepository.query(someModel=model)
  ```

  Finall query will looks like this:

  ```sql
  select (id, name, greet) from table where name='first hello' or greet='hello boi';
  ```



  There are some prebuilded methods for saving, updating, removing and find new id. Those methods do not need to be defined in your custom repository. They are in `CheeseRepository` and are accessible from custom repositories.

  - `findAll()`
      - finds all rows of table
  - `find(primaryKey)`
      - finds one model by `primaryKey`
  - `findWhere(**columns)`
      - finds all rows with `value` of columns
      - `**columns` is kwargs so dict where `keys` are column names and its `values` are ... ehm values
  - `findOneWhere(**columns)`
      - finds one model with `value` of columns
      - `**columns` is same as in `findWhere`
  - `findNewId()`
      - finds new ID (free one)
  - `save(obj)`
      - inserts new row into database by `obj` (it is CheeseModel)
  - `update(obj)`
      - updates values in database by id of `obj`
  - `delete(obj)`
      - deletes row from database by id of `obj`
  - `exists(**columns)`
      - return `true` if at least one row exists
      - `**columns` is same as in `findWhere`
  - `model()`
      - returns new instance of `CheeseModel` and finds to it free id via `findNewId()`



  Models are non-static objects which contains data from one row of database. There is class `CheeseModel` . This class stores your data and is returned from `repository` (if called method is annotated with `#@return` annotation and values `one` or `array`).

  Every instance of `CheeseModel` has variables `modelName` and `scheme`.

  - `modelName` is defined in repository with `#@dbModel` annotation
      - it is only for you to recognize which model is which
  - `scheme` is list of column names and is also defined in repository with `#@dbScheme` annotation

  You can add your own variables (that does not matter) but when model is returned from repository query call then there are defined variables by `scheme`. Those variables are filled with values from database.

  Example for this repository:

  ```python
  from cheese.modules.cheeseRepository import CheeseRepository




  class UserRepository(CheeseRepository):

      
      
      def getOlderThen(userAge):
          return CheeseRepository.query(age=userAge)
  ```

  We can do this:

  ```python
  users = UserRepository.getOlderThen(20) # returns array of CheeseModel with .age > 20


  for user in users:
      print(user.id, user.user_name, user.age)


  print(users[0].modelName)

  print(users[0].scheme)
  ```




  `toJson()` method creates python dictionary from storred variables of model. But only from variables which are in database scheme.

  This example uses some of models from previous example.

  ```python
  print(user.toJson())
  ```

  Output:

  ```json
  {
      "ID": 0,
      "USER_NAME": "idk Joe",
      "AGE": 69
  }
  ```



  `toModel(jsn)` method sets variables of model by `jsn` argument. `jsn` can be dictionary or any iterable structure (list, tuple, Row (this is object from `pyodbc` library))

  :bangbang: If you pass anything else (but iterable) than dictionary it MUST be in order by `#@dbScheme`.

  ```python
  user.toModel([0, "Joe", 15]) # list example
  print(user.toJson())

  user.toModel((0, "Joe Boy", 15)) # tuple example
  print(user.toJson())

  user.toModel({"id": 0, "user_name": "Joe", "age": 4}) # dictionary example
  print(user.toJson())

  user.toModel({"id": 0, "user_name": "Joe", "age": 4, "fancy_level": 45}) # dictionary example
  print(user.toJson())
  ```

  Output:

  ```json
  {
      "ID": 0,
      "USER_NAME": "Joe",
      "AGE": 15
  }

  {
      "ID": 0,
      "USER_NAME": "Joe Boy",
      "AGE": 15
  }

  {
      "ID": 0,
      "USER_NAME": "Joe",
      "AGE": 4
  }
  // you can see that "fancy_level" variable is not in json because it is not defined in database scheme
  {
      "ID": 0,
      "USER_NAME": "Joe",
      "AGE": 4
  }
  ```



  `setAttrs(**attrs)` is pretty similar to `toModel(jsn)` but arguments you pass can be written like kwargs:

  ```python
  user.setAttrs(id=1, user_name="Jimbo", age=47)
  print(user.toJson())
  ```

  Output:

  ```json
  {
      "ID": 1,
      "USER_NAME": "Jimbo",
      "AGE": 47
  }
  ```





  Always use repository method `model()` . This method will automatically finds free id for your model. This is maybe not the best way to do it so I will probably change it so id will be find during save. But USE it.

  :x:

  ```python
  model = CheeseModel(modelName, scheme)
  ```

  :heavy_check_mark:

  ```python
  model = YourRepository.model()
  ```



  Testing is very important part of programming. It will tell you if you fucked something up. Cheese, because of database connection (and because it is fun creating it), has it's own test system.

  Tests are run during start of application after [Build](#3-build) when application is in debug mode.



  There is list of classes which your test class file should contains. Everything will be clear when you check [Test examples](#84-test-examples).



  ```python
  from Cheese.test import UnitTest
  ```

  `UnitTest` is class with methods that will throw (raise) `TestError`  exception which signalize to Cheese test engine that this test fails because of the result is not as expected. Those methods are `static` .

  Methods of `UnitTest` :

  ```python
  UnitTest.assertEqual(value, template, comment)
  ```

  If `value` is not same as `template` the `TestError` will be raised and test fails. Also `comment` will be print with fail message.

  ```python
  UnitTest.assertTrue(value, comment)
  ```

  If `value` is not equal `True` the `TestError` will be raised and test fails.

  ```python
  UnitTest.assertFalse(value, comment)
  ```

  If `value` is not equal `False` the `TestError` will be raised and test fails.



  ```python
  from Cheese.pointer import Pointer
  ```

  Usage of `Pointer` is approximately similar as in C/C++. But because python does not have this amazing feature I had to make my own. `Pointer` is just some pointer (:D) to any variable you need. I will show you that in some [Test examples](#84-test-examples) .

  Methods of `Pointer` :

  ```python
  Pointer.getValue()
  ```

  Return value to which `Pointer` points.

  ```python
  Pointer.setValue(value)
  ```

  Sets value to which `Pointer` points. (You won't need it)



  ```python
  from Cheese.mock import Mock
  ```

  `Mock` is class that you can use if you need to test some method which is using some of your repository. You can substitute `return` of any method with your own values and for any argument input.

  Methods of `Mock` :

  ```python
  mock = Mock(nameOfRepository)
  ```

  This is constructor (initializer) of `Mock` class. Every `Mock` is non-static class which mocks one repository.

  ```python
  mock.whenReturn(nameOfMethod, value, **kwargs)
  ```

  When there is called `nameOfRepository.nameOfMethod()` during test and arguments are same as `**kwargs` (dictionary of arguments), then `value` is returned.

  ```python
  mock.catchArgs(pointer, nameOfArgument, nameOfMethod, **kwargs)
  ```

  When there is called `nameOfRepository.nameOfMethod()` during test and arguments are same as `**kwargs`, then `pointer.value` will be `**kwargs[nameOfArgument]` .

  As I said... everything will be clear at the end of paragraph in examples.



  Like everything else tests need to be annotated with Cheese annotations. One test file should contains only one test class (it can be more but... it is probably not best practise). This test class needs to be annotated with `#@testclass` annotation. This annotation can contains some description of test class:

  ```python

  class helloTest:
  ```

  If you add `#@ignore;` annotation then whole file will be ignored during testing:

  ```python


  class helloTest:
  ```



  Test methods need `#@test` annotation and also it can contain a description:

  ```python

  @staticmethod
  def helloWorldTest():
  ```

  Ignored test method:

  ```python


  @staticmethod
  def helloWorldTest():
  ```



  For method:

  ```python

  class HelloWorldController(CheeseController):

      
      @staticmethod
      def helloWorld(server, path, auth):
          return "hello"
  ```

  Could be test like this:

  ```python

  @staticmethod
  def helloWorldTest():
      controller = HelloWorldController()

      resp = controller.helloWorld(None, None, None)

      value = resp[0].decode()
      httpCode = resp[1]

      UnitTest.assertEqual(value, "hello", "Response was not 'hello'")
      UnitTest.assertEqual(httpCode, 200, "Status code was not 200")
  ```

  For method:

  ```python

  class HelloWorldController(CheeseController):

      
      @staticmethod
      def helloWorld(server, path, auth):
          hello = HelloRepository.model()

          hello.setAttrs(hello_value="Hello boi")

          return CheeseController.createResponse(hello.toJson(), 200)
  ```

  Could be test like this:

  ```python

  @staticmethod
  def helloWorldTest():
      controller = HelloWorldController()

      mock = Mock("HelloRepository") # mocking HelloRepository
      mock.whenReturn("findNewId", 0) # because model() method is using findNewId()

      resp = controller.helloWorld(None, None, None)

      value = json.loads(resp[0])
      httpCode = resp[1]

      
      templateResponse = {
          "hello_value": "Hello boi",
          "id": 1 # because findNewId() adds 1 every time
      }

      UnitTest.assertEqual(value, templateResponse, "Response was not as expected")
      UnitTest.assertEqual(httpCode, 200, "Status code was not 200")
  ```

  For method:

  ```python

  class HelloWorldController(CheeseController):

      
      @staticmethod
      def helloWorld(server, path, auth):
          hello = hr.model()

          hello.setAttrs(hello_value="Hello my friend")
          hr.save(hello)

          allHellos = hr.findAll()

          return cc.createResponse(cc.modulesToJsonArray(allHellos), 200)

  ```

  Could be test like this:

  ```python

  @staticmethod
  def helloWorldTest():
      controller = HelloWorldController()
      mock = Mock("HelloRepository")

      pointer = Pointer()

      mock.whenReturn("findNewId", 0) # in method model() as in previous example
      """
      if method save() will be called then pointer.value will be set to value of argument "obj"
      """
      mock.catchArgs(pointer, "obj", "save")
      """
      if findAll() will be called then array
      ([pointer], that one item will be value of pointer)
      will be returned
      """
      mock.whenReturn("findAll", [pointer])

      resp = controller.helloWorld(None, None, None)

      value = json.loads(resp[0])
      httpCode = resp[1]

      
      templateResponse = {
          "hello_value": "Hello boi",
          "id": 1 # because findNewId() adds 1 every time
      }

      UnitTest.assertEqual(value, [templateResponse], "Response was not as expected")
      UnitTest.assertEqual(httpCode, 200, "Status code was not 200")
  ```



  I have create some useful javascript functions. Those scripts can be used if CORS is enabled or you can download them and insert them into your project for offline use.

  Some of those scripts (for example `alerts.js`) needs a `css` for proper functionality. You can change it but if scripts needs `css` then you should add classes with same names like which are in given `.css` file. (hope you understand it).

  All imports:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/time.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/cookies.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/communication.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/tableBuilder.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/alerts.js"></script>

  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/autoComplete.js"></script>
  ```



  Easy way to create a custom combobox. Credit belongs to w3schools: https://www.w3schools.com/howto/howto_js_autocomplete.asp

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/autoComplete.js"></script>

  <!-- necessary dependencies -->
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  ```

  Needs css:

  ```html
  <link rel="stylesheet" href="https://kubaboi.github.io/CheeseFramework/public/styles/autocompleteStyle.css">
  ```

  Variables of css:

  ```css
  /* colors */
  --light-color /* background color of main dialog */
  --text-color /* text color of not chosen row */
  --secondary-color /* background color of chosen row */

  /* classes */
  .autocomplete /* better not to be changed */
  .autocomplete-items /* all items of autocomplete list */
  .autocomplete-items div /* one item of autocomplete list */
  .autocomplete-items div:hover
  .autocomplete-active /* onclick */
  ```

  Functions:



  Method generates html elements for autocomplete dialog

  - `inp` - input html element (html object)
  - `arr` - array of options for autocomplete



  Script for saving and reading cookies.

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/cookies.js"></script>
  ```

  Functions:



  Sets a cookie

  - `cname` - string name of the cookie
  - `cvalue` - value of the cookie
  - `exdays` - float value of how long will cookie be storred (in days)



  Returns value of cookie

  - `cname` - string name of the cookie



  Script that sends `xmlhttp` requests. There are two global variables. You can change them anywhere in your scripts (but change will be proceede only if your scripts are imported AFTER `communication` script)

  - `debug` - default setting is `true`, change it if you do not want to print informations about requests
  - `authorization` - variable that will be send like `Authorization` header in request (if empty than this header won't be created). For example: `authorization="userName:password"`

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/communication.js"></script>

  <!-- necessary dependencies -->
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/time.js"></script>
  ```

  Functions:



  Returns Promise with server JSON response.

  - `type` - HTTP method ("GET"/"POST")
  - `url` - request url in most cases only endpoint. It can be used even for external server but than `url` needs to have `http[s]://server/endpoint` structure
  - `request` - default null (it is for "GET"). For "POST" it is just JavaScript object

  Usage:

  ```javascript
  async function getData() {
      var response = await callEndpoint("POST", "/endpoint", someObject);
      if (response.ERROR == null) {
          console.log(response);
      }
      else {
          alert(response.ERROR);
      }
  }
  ```



  Script for creating html elements.

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  ```

  Functions:



  Returns created element

  - `type` - html tag ("div", "label"...)
  - `parent` - parent element (element will be append to parent if it is not null)
  - `innerHTML` - innerHTML of created element
  - `attributes` - list of attributes ("id", "class", "onclikc"...)
      - one attribute is JavaScript object contaning "name" and "value"

  Usage:

  ```javascript
  // function will create div and button inside that div with text "Click me :)"
  // button will have class "coolButton" and onclick will print in console "hello"
  function makeElement() {
      var div = createElement("div");
      var element = createElement("button", div, "Click me :)",
          [
              {"name": "onclick", "value": "console.log('hello');"},
              {"name": "class", "value": "coolButton"}
          ]
      );
  }
  ```



  Return value of element with id = `id` . It will parse value based on element type. For `text` or `datetime` it will be string. For `number` it will be integer and for `radio` or `checkbox` it will be boolean.

  - `id` - id of element



  Script for creating tables.

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/tableBuilder.js"></script>

  <!-- necessary dependencies -->
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  ```

  Functions:



  Sets innerHTML of table to "".

  - `table` - html element (do not need to be table)



  Adds one row in the end of the table.

  - `table` - html element (need to be table)
  - `cells` - array of cell objects
      - cell are javascript objects containing "text" and "attributes" which is a list
      - attributes are javascript objects containing "name" and "value"
  - `rowAttributes` - list of attributes for row element ("id", "class", "onclick"...)
      - attributes are javascript objects containing "name" and "value"



  Adds header to the end of the table. Make sure that you are adding it like first. (If you do not want to have header in the end or in the middle of table ofc).

  - `table` - html element (need to be table)
  - `cells` - array of cell objects
      - cell are javascript objects containing "text" and "attributes" which is a list
      - attributes are javascript objects containing "name" and "value"
  - `rowAttributes` - list of attributes for row element ("id", "class", "onclick"...)
      - attributes are javascript objects containing "name" and "value"



  Alerts script allows to create custom alerts.

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/alerts.js"></script>

  <!-- necessary dependencies -->
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  ```

  Need css:

  ```html
  <link rel="stylesheet" href="https://kubaboi.github.io/CheeseFramework/public/styles/alertStyle.css">
  ```

  Variables of css:

  ```css
  /*
  You can create your own animations, classes, colors or just change mine...
  If you make something cool I would love to see it :)
  */

  /* colors */
  --light-color /* background color of main dialog */
  --text-color /* text color */
  --secondary-color /* border color */

  /* classes */
  .alertDiv /* better not to be changed (except for colors) */
  .alertH2 /* alert title */
  .alertLabel /* alert label */
  .alertOKbutton /* ok button */
  .alertOKbutton:hover
  .alertCancelButton /* cancel button */
  .alertCancelButton:hover
  .divOkAlert /* alert which pop up on the left top and it is green */
  .divWrongAlert /* alert which pop up on the left top and it is red */

  /* animations */
  @keyframes showAlert {} /* show animation for .alertDiv (slides from top) */
  @keyframes hideAlert {} /* hide animation for .alertDiv (slides into top) */
  @keyframes okShowAlert {} /* show animation for .divOkAlert and .divWrongAlert (slides from left) */
  @keyframes okHideAlert {} /* hide animation for .divOkAlert and .divWrongAlert (slides into left) */
  ```

  Functions:



  Shows alert. There are not default values (it would be soooo long).

  - `title` - title of alert (header)
  - `message` - message of alert (label)
  - `divClass` - css class name
      - default is `"alertDiv"`
  - `animation` - show animation
      - default is `{"name":"showAlert","duration":"0.5s"}`
      - "name" is css animation name
      - "duration" is duration of animation
  - `closeAnimation` - close animation
      - default is `{"name":"hideAlert","duration":"0.5s"}`



  Show confirm alert. It will be closed after user clicks at "OK"/"Close" button.

  - `title` - title of alert (header)
  - `message` - message of alert (label)
  - `ifOk` - function done after "OK" confirmation
  - `divClass` - css class name
      - default is `"alertDiv"`
  - `animation` - show animation
      - default is `{"name":"showAlert","duration":"0.5s"}`
  - `closeAnimation` - close animation
      - default is `{"name":"hideAlert","duration":"0.5s"}`

  Usage:

  ```javascript
  function func(v) {
      console.log(v);
  }

  showConfirm("Really?",
      "Do you really want to print hello??????!!!!",
      function() {func("Hello :)");});
  ```



  Show alert which will be after `time` miliseconds closed

  - `title` - title of alert (header)
  - `message` - message of alert (label)
  - `time` - time in miliseconds
  - `divClass` - css class name
      - default is `"alertDiv"`
  - `animation` - show animation
      - default is `{"name":"showAlert","duration":"0.5s"}`
  - `closeAnimation` - close animation
      - default is `{"name":"hideAlert","duration":"0.5s"}`



  Show ok alert (the green one on the left). If `timeAlert` is 0 then the alert won't be closed automaticaly

  - `title` - title of alert (header)
  - `message` - message of alert (label)
  - `timeAlert` - time in miliseconds (if 0 there won't be timer)



  Show wrong alert (the red one on the left). If `timeAlert` is 0 then the alert won't be closed automaticaly

  - `title` - title of alert (header)
  - `message` - message of alert (label)
  - `timeAlert` - time in miliseconds (if 0 there won't be timer)



  Script for downloading parts of web dynamically. It is prepared for `CheeseApplications`. I do not even know if it is best practice. :no_good:

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/loadPage.js"></script>

  <!-- necessary dependencies -->
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/elementManager.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/communication.js"></script>
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/time.js"></script>
  ```

  Functions:



  Parts of the web need to be inside folder `webParts` and paths inside arrays does not contain full path (`main/header` for `header.html` inside `/web/webParts/main/`)

  - `startArray` - list of paths for part that need to be loaded before some javascript intialization
  - `doAfter` - javascript initialization, it is a function with processess that need loaded web parts from startArray
  - `afterArray` - list of paths for part that do need to be loaded before initialization



  Creates div with attributeClass class, innerHTML from file and will be inside parent. And returns that div.

  - `name` - name of html file (without .html)
  - `path` - folder without "/webParts/" and withou name
  - `parentId` - id of html object which will contain this part of web
  - `attributeClass` - class name of div



  This script has only one function which returns actual time. It is used by `communication.js` for logs timestamps.

  Import:

  ```html
  <script src="https://kubaboi.github.io/CheeseFramework/public/scripts/time.js"></script>
  ```

  Functions:



  Return string of actual time formated as `hh:mm:ss`




  Here is a cake :cake: but it is a lie


pkgId: 46980da8f559e1261c2f5f735c7a9d8561a6ee4d7cd165507a5b88bcfe073ea9
name: python-Cheetah-GH
arch: src
version: 0.1.8
epoch: 0
release: 1
url: https://github.com/JamesParrott/Cheetah_GH
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cheetah-GH-0.1.8-1.src.rpm
checksum_type: sha256
summary:
  Runs Grasshopper components and stops Rhino from Python components. Optionally runs Rhino3D and Grasshopper from the command line.

description:
  Cheetah runs Grasshopper components, and runs Grasshopper from the command line.  Output from Python components in Grasshopper can be sent to the command line.  Cheetah can stop
  Grasshopper from a Python component, and return any exit code.

  The CLI Rhino runner requires Python 3.

rpm_license:
  Copyright 2024 James Parrott  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: c2f942a4f1451e1894a252a830ff8fd913d428e1892f2703f9fda9004e1d1aea
name: python-ChemE
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Various functions and data for Chemical Engineering Students
url: https://github.com/ConciseVerbosity18/ChemE_CV
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChemE-0.7.1-1.src.rpm
checksum_type: sha256
description:
  This package was birthed to help Chemical Engineers with the massive tables that we typically have to look through. There are also some other features.


pkgId: ffd56c670a62619b7476faef8fdc743fc447b61746b0bdafd2004fdbe3bde098
name: python-ChemMod
arch: src
version: 0.0.15
epoch: 0
release: 1
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChemMod-0.0.15-1.src.rpm
checksum_type: sha256
summary:
  Python program for practical plotting and calculation in chemistry. ChemMod is developed as a userfriendly python package for chemistry students. The package contains a variety of different useful plot functions and formula functions from chemistry e.g. buffer diagrams, Gibbs-energy functions and regression tools.

description:
  Project: ChemMod.py


  Description:
  <svg fill="none" viewBox="0 0 600 300" width="600" height="300">
    <foreignObject width="100%" height="100%">
  <div id="d1" class="heading">
  	<h1>Chemistry Modules<hr style="display:block;background-color:#2B3856;padding:3px;border:none;"></h1>
  </div>
  <div id="d2" class="description">
  	<p1><br>Python program for practical plotting and calculation in chemistry. ChemMod is developed as a userfriendly python package for chemistry students. The package contains a variety of different useful plot functions and formula functions from chemistry e.g. buffer diagrams, gibs energy functions, reaction kinetics order plot linear regression.<br><br></p1>
  </div>
    </foreignObject>
  </svgg


  Table of contents:

  	1.	arrhenius_plot()
  	2.	bjerrum_plot()
  	3.	equil()
  	4.	gibbs_plot()
  	5.	M()
  	6.	order_plot()

  Built with:

  	Python - Google Colaboratory

  	Python packages:
  		numpy
  		math
  		math.plotlib

  Requires:

  	Python
  	numpy as np
  	matplotlib as plt

url:
  https://chemmod.gumroad.com/l/ymkbm?_gl=1*9a8men*_ga*MTUzMDIwNTM4LjE3MTEzMTE3MTU.*_ga_6LJN6D94N6*MTcxMTM2NDc4OC4zLjEuMTcxMTM2NDc4OC4wLjAuMA..


pkgId: 8298b6ca7606d3ad46afa4fc96243739f79671bc70cd01e8f220f882bd3abae5
name: python-ChemMod
arch: src
version: 0.0.20
epoch: 0
release: 1
url: https://www.facebook.com/groups/1241482943732179
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChemMod-0.0.20-1.src.rpm
checksum_type: sha256
summary:
  Python program for practical plotting and calculation in chemistry. ChemMod is developed as a userfriendly python package for chemistry students. The package contains a variety of different useful plot functions and formula functions from chemistry e.g. buffer diagrams, Gibbs-energy functions and regression tools.

description:
  Project: ChemMod.py


  Description:
  <svg fill="none" viewBox="0 0 600 300" width="600" height="300">
    <foreignObject width="100%" height="100%">
  <div id="d1" class="heading">
  	<h1>Chemistry Modules<hr style="display:block;background-color:#2B3856;padding:3px;border:none;"></h1>
  </div>
  <div id="d2" class="description">
  	<p1><br>Python program for practical plotting and calculation in chemistry. ChemMod is developed as a userfriendly python package for chemistry students. The package contains a variety of different useful plot functions and formula functions from chemistry e.g. buffer diagrams, gibbs energy functions, reaction kinetics order plot linear regression.<br><br></p1>
  </div>
    </foreignObject>
  </svgg


  Table of contents:

  	Equation
  	1.	element_data
  	2.	equil()
  	3.	M()

  	Help
  	1.	content_data
  	2.	info()
  	3.	content()

  	Plot
  	1.	arrhenius_plot()
  	2.	bjerrum_plot()
  	3.	equilibrium()
  	4.	gibbs_plot()
  	5.	order_plot()

  Built with:

  	Python - Google Colaboratory

  	Python packages:
  		numpy
  		math
  		math.plotlib

  Requires:

  	Python 3.13
  	numpy as np
  	matplotlib as plt


pkgId: 592a09afd74ffa068ad335c203a55c8977a47020120281a67711cd468ede3c60
name: python-ChemW
arch: src
version: 0.3.5
epoch: 0
release: 1
url: https://github.com/freiburgermsu/chemw
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChemW-0.3.5-1.src.rpm
checksum_type: sha256
summary:
  Calculates the Molecular Weight, to the appropriate significant digits, from a string of an arbitrary chemical formula, a protein sequence of one- or three-letter codes, or chemical common names that are recognized by PubChem.

description:
  |PyPI version| |Actions Status| |docs| |Downloads| |License|
  The ``ChemW`` library contains three packages, each with a distinct use-case, which are detailed in the following sections.
  The ``ChemMW`` package parses any chemical formula that adheres to `chemical conventions <https://en.wikipedia.org/wiki/Chemical_formula>`_ -- which can consist of any combination of elements and decimal stoichiometry -- and calculates the MW of the chemical formula with the most accurate elemental masses that are available, per the `chemicals module <https://pypi.org/project/chemicals/>`_. The MW is precisely constrained to the significant digits of constituent elements in the chemical formula.
  The ``Proteins`` and ``PHREEQdg`` packages are applications of the ``ChemMW`` package. The ``Proteins`` package returns the mass of a protein by either parsing a string of a protein sequence, or by parsing a `FASTA-formatted file <https://en.wikipedia.org/wiki/FASTA_format>`_. This is applied in the `Codons module <https://pypi.org/project/codons/>`_ for genome-scale biology and bioengineering. The ``PHREEQdb`` package parses a `PHREEQ database <https://www.usgs.gov/software/phreeqc-version-3>`_, calculates the MW of each mineral in the database, and exports a JSON of all mineral masses from the database. This is pivotally applied in the PHREEQC databases of the `ROSSpy module <https://pypi.org/project/ROSSpy/>`_ for reverse osmosis research.
  The ``ChemW`` library is offered with the `MIT License <https://opensource.org/licenses/MIT>`_\. Examples of the module are available in the examples directory of the `ChemW GitHub repository <https://github.com/freiburgermsu/ChemW>`_. Please submit errors or inaccuracies as `GitHub issues <https://github.com/freiburgermsu/ChemW/issues>`_ so that they may be resolved.


pkgId: f11fd1b223c0a8fbf492eb43224ef234e20862aae544b2f0e64d09e5b72f2862
name: python-CherryOnTop
arch: src
version: 1.0
epoch: 0
release: 1
summary: Helper utilities for building JSON APIs with CherryPy.
url: https://github.com/csira/cherryontop
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CherryOnTop-1.0-1.src.rpm
checksum_type: sha256
description:
  CherryOnTop is a small set of utilities and boilerplate for building JSON
  API's with CherryPy, it contains convenience methods for route-binding and
  some tooling for graceful error propagation. Thanks for taking a look.


pkgId: 5a22714042571811e90a34364b9587ae3d5054aed05d83be8b78ca002952aa09
name: python-CherryPy
arch: src
version: 18.10.0
epoch: 0
release: 1
summary: Object-Oriented HTTP framework
url: https://www.cherrypy.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CherryPy-18.10.0-1.src.rpm
checksum_type: sha256
description:
  CherryPy is available as part of the Tidelift Subscription.
  The CherryPy maintainers and the maintainers of thousands of other packages
  are working with Tidelift to deliver one enterprise subscription that covers
  all of the open source you use.
  `Learn more <https://tidelift.com/subscription/pkg/pypi-cherrypy?utm_source=pypi-cherrypy&utm_medium=referral&utm_campaign=github>`_.


pkgId: b86e626fc497ede49425def343dea0c070707107bbb2d1faf3ce756b453f7914
name: python-Cherrydoor
arch: src
version: 0.8.1
epoch: 0
release: 1
url: https://github.com/oplik0/cherrydoor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cherrydoor-0.8.1-1.src.rpm
checksum_type: sha256
summary:
  An overengineered rfid lock manager created for my school community. Made for Raspberry Pi connected with another microcontroler that send and receieves rfid data via UART

description:
  [![python tests](https://github.com/wisniowa56/cherrydoor/workflows/python%20tests/badge.svg)](https://github.com/wisniowa56/cherrydoor/actions?query=workflow%3A%22python+tests%22)
  [![Maintainability](https://api.codeclimate.com/v1/badges/7b05467561774c611f8c/maintainability)](https://codeclimate.com/github/oplik0/cherrydoor/maintainability)
  [![HitCount](http://hits.dwyl.io/wisniowa56/cherrydoor.svg)](http://hits.dwyl.io/wisniowa56/cherrydoor)

  <h1 align="center">cherrydoor</h1>
  <p align="center">
    <img src="https://raw.githubusercontent.com/wisniowa56/cherrydoor/v0.8.1/cherrydoor/static//images/logo/logo.svg">
  </p>
  Prosta webaplikacja do zarządzania i przeglądania statystyk wykorzystania zamka RFID korzystająca z Flaska i MongoDB.



  1. Zaintaluj `Cherrydoor` korzystając z pip i pypi:

  ```bash
  pip3 install Cherrydoor
  ```

  Albo pobierz wheel danego wydania i zainstaluj:

  ```bash
  pip3 install ./Cherrydoor-<version>-py3-none-any.whl
  ```

  2. Doinstaluj dodatkowe zależności i skonfiguruj trochę rzeczy korzystając z wbudowanego skryptu instalacyjnego:

  ```bash
  cherrydoor install
  ```

  3. Program powinien być już uruchomiony przez systemd na porcie 5000. Możesz go restartować/zatrzymywać/itp. korzystając z `systemctl --user <komenda> cherrydoor`. Jeśli chcesz go uruchomić bez korzystania z usługi, skorzystaj ze skryptu `cherrydoor start`.


pkgId: bdfa643e5f4194349eaad9e7f4bb385104614a4dc191a639fa0b34c3d1ec48cf
name: python-Cherv
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: An analogue of CowSay, only instead of a cow there is a worm.
url: https://github.com/AyaalTech/wormsay-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cherv-0.5.2-1.src.rpm
checksum_type: sha256
description:
      An analogue of CowSay, only instead of a cow there is a worm.

      Usage:

      ``python -m cherv [your message]``

      The message can be entered in any length.


pkgId: 42c152833451273aa86cfde34b24110afadd7174850c2dc89811a2b1860c38d7
name: python-ChessAnalysisPipeline
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: CHESS analysis pipeline framework
url: https://github.com/CHESSComputing/ChessAnalysisPipeline
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChessAnalysisPipeline-0.0.16-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/600053436.svg)](https://zenodo.org/badge/latestdoi/600053436)
  ![pylint](https://github.com/CHESSComputing/ChessAnalysisPipeline/actions/workflows/pylint-check.yml/badge.svg)
  ![unittests](https://github.com/CHESSComputing/ChessAnalysisPipeline/actions/workflows/unittests.yml/badge.svg)


  CHAP is a package that provides a framework for executing data anlaysis pipelines. The package can be found on PyPI and conda-forge.


  There are several subpackages within CHAP that contain specialized items to handle specific types of data processing in the CHAP framework. Dependencies for these subpackages can be found in `CHAP/<subpackage_name>/environment.yml`.


  Documentation for the latest version can be found on [this project's github pages site](https://chesscomputing.github.io/ChessAnalysisPipeline/).


  The `galaxy-tools/` directory contains a set of CHAP-based tools for use in the [Galaxy](https://galaxyproject.org) science gateway.


pkgId: 131f3feb0262b239bf857e0e280089f98cfe439caf6d226a2c19772758af3b83
name: python-Chessnut
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A basic chess model to imports/export FEN & finds moves.
url: https://github.com/cgearhart/Chessnut
rpm_license: UNLICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chessnut-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Chessnut is a simple chess board model written in Python. Chessnut is not a chess engine – it has no AI to play games, and it has no GUI. It is a simple package that can import/export games in Forsyth-Edwards Notation (FEN), generate a list of legal moves for the current board position, intelligently validate & apply moves (including en passant, castling, etc.), and keep track of the game with a history of both moves and corresponding FEN representation.

  Chessnut is not written for speed, it is written for simplicity (there are only two real classes, and only about 200 lines of code). By adding a custom move evaluation function, Chessnut could be used as a chess engine. The simplicity of the model lends itself well to studying the construction of a chess engine without worrying about implementing a chess model, or to easily find the set of legal moves for either player on a particular chess board for use in conjunction with another chess application.


pkgId: fdcca77db65597a60b04faacfd063c1ddaca11f6cbe6b6c82fee29837c1c709b
name: python-ChiMera-ModelBuilder
arch: src
version: 2.0.15
epoch: 0
release: 1
url: https://github.com/tamascogustavo/chimera
rpm_license: glp3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChiMera-ModelBuilder-2.0.15-1.src.rpm
checksum_type: sha256
summary:
  ChiMera: An easy-to-use pipeline for Genome-based Metabolic Network reconstruction, evaluation, and visualization.

description:
  ChiMera is a python-based tool for genome-scale metabolic model
  reconstruction, evaluation and visualization
  Documentation
  ~~~~~~~~~~~~~
  For more details please check: https://github.com/tamascogustavo/chimera
  Instalation
  ~~~~~~~~~~~
  Can be easily installed using **pip**:
  Additionally, you must install diamond and CPLEX (please check the
  documentation for details).
  Credits and License
  ~~~~~~~~~~~~~~~~~~~
  Developed by Gustavo Tamasco
  Released under an GLP3 License


pkgId: 28cc736491c6676c8afed519b83c30fa1d39c845f007552a9647b2e2ccc62d38
name: python-Chibchas
arch: src
version: 0.2.18b0
epoch: 0
release: 1
summary: InstituLAC Automation Tools
url: https://github.com/colav/Chibchas
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chibchas-0.2.18b0-1.src.rpm
checksum_type: sha256
description:
  <center><img src="https://raw.githubusercontent.com/colav/colav.github.io/master/img/Logo.png"/></center>


  InstituLAC Automation Tools


  Package allows to download data from InstituLAC/Minciencias (Colombia) and upload it to Google Drive to do validation




  `pip install chibchas`



  Let's start the server executing
  ```.sh
  chibchas_server
  ```
  Or using some command line options
  ```.sh
  chibchas_server --port 8080 --ip x.x.x.x
  ```

  where `x.x.x.x` is your local IP

  you can access to the server for the endpoints for example on: http://127.0.1.1:8080
  depending on the IP and PORT that you are providing to `chibchas`.


  To obtain the information of the first two groups and save the output files in `/home/usario/somedir` for InstituLAC official institution name `"UNIVERSIDAD DE ANTIOQUIA"`, use
  ```bash
  chibchas_institulac --gdrive_path=/home/restrepo/tmp --institution="UNIVERSIDAD DE ANTIOQUIA" --end=2
  ```
  or check `chibchas_institulac --help` for further options. The default `--end` option, save output files for all the avalaible "Avalados" groups.

  The `--gdrive_path` can be a Google Drive folder. See below:


  Create a project https://developers.google.com/workspace/guides/create-project

  create a oauth credentials https://developers.google.com/drive/api/v3/enable-drive-api

  download the json file with configuration
  ![JSON Api Config](img/apijson.png?raw=true "Download json with credentials")



  required administrative permissions with apt.

  `apt install rclone`


  configure rclone following [this instructions](https://rclone.org/drive/)

  client_id and client_secret can be found on the json previously downloaded.

  Mount the filesystem, it doesn't required administrative permissions.

  `
   rclone mount -v  --daemon remote:project/path  local/path
  `



  BSD-3-Clause License


  http://colav.udea.edu.co/


pkgId: 1a3d89dbfc30a0d015f6286d16b2397da14159d90883f6025bfee36ebd7a4ff9
name: python-ChildProject
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: LAAC@LSCP
url: https://github.com/LAAC-LSCP/ChildProject
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChildProject-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/childproject.svg)](https://pypi.org/project/childproject/)
  [![GitHub tests](https://github.com/LAAC-LSCP/ChildProject/actions/workflows/tests.yml/badge.svg)](https://github.com/LAAC-LSCP/ChildProject/actions/workflows/tests.yml)
  [![Travis CI Status](https://app.travis-ci.com/LAAC-LSCP/ChildProject.svg?token=1d35csHFpystSMdwuSY8&branch=master)](https://app.travis-ci.com/LAAC-LSCP/ChildProject)
  [![ReadTheDocs](https://readthedocs.org/projects/childproject/badge/?version=latest)](https://childproject.readthedocs.io/en/latest/)
  [![License](https://img.shields.io/pypi/l/childproject.svg)](https://github.com/LAAC-LSCP/ChildProject/blob/master/LICENSE)
  - [Introduction](#introduction)
  - [Available tools](#available-tools)
  - [Installation](#installation)

rpm_license:
  MIT License  Copyright (c) 2021 Lucas Gautheron  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: c0074ca942018c32df9c112ed096de6e3362eef53bb90c9d6d5eb21fe158d1c0
name: python-Chill-Streams
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Chill electronica streaming
url: https://github.com/zcutlip/chill_streams
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chill-Streams-0.4.4-1.src.rpm
checksum_type: sha256
description:
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/zcutlip/chill_streams/main.svg)](https://results.pre-commit.ci/latest/github/zcutlip/chill_streams/main)





  This project is a directory of chill electronica streaming radio stations. If you like [DEF CON radio](https://somafm.com/defcon/) or [Groove Salad](https://somafm.com/groovesalad/) on Soma.fm, this is for you.

  This project provides three things:

  1. A directory of streaming radio station URLs
  2. A Python API for accessing that directory
  3. A command-line utility to present a menu and launch VLC with a selected URL





  - OS:
    - Probably most modern (reasonable) Linux distros, but late Ubuntu releases are known to work
    - Late macOS versions (tested on macOS 11.4 with up-to-date homebrew installed)
    - Windows probably won't work (but might be easily made to, let me know)
  - Python >= 3.8 (3.9 preferred)
  - VLC, with the `vlc` command line utility on your `$PATH` (the homebrew VLC cask on macOS sets this up for you)
    - Alternatively you may set `VLC_PATH` to point to a `vlc` executable:
    - e.g. `export VLC_PATH=~/Applications/VLC.app/Contents/MacOS/VLC`

  > Note: VLC has a [bug](https://code.videolan.org/videolan/vlc/-/issues/26308) on Apple Silicon and ncurses is broken. Workarounds:
  > - **Recommended**: create a symlink inside `~/.terminfo`:
  > ```
  > % mkdir ~/.terminfo
  > % # if TERM=xterm-256color:
  > % ln -s /usr/share/terminfo/78 ~/.terminfo/x
  > % # if TERM=screen-256color:
  > % ln -s /usr/share/terminfo/73 ~/.terminfo/s
  > ```
  > - Install the x86-64 version
  > - Run with `--gui`, disabling ncurses



  You can install directly from PyPI:

  ```bash
  pip3 install --user Chill-Streams
  ```



  The `vlc-radio` utility starts up VLC Media Player playing one of the stations in the directory.

  It has a few modes of operation:

  - VLC running in text (ncurses) mode or GUI mode
  - An interactive menu of stations to select from
  - Direct play by station number
  - Direct play by station name
  - If a partial station name is provided and the match is ambiguous, a reduced menu is presented
  - First match: if the match is ambiguous, directly play the first option



  ```console
  usage: vlc-radio [-h] [-f] [--gui] [--write-shell-script] [--version]
                   [station]

  Chill Streams: Chill electronica streaming [version 0.1.1.dev0]

  positional arguments:
    station               Index or (partial) name of station to play

  optional arguments:
    -h, --help            show this help message and exit
    -f, --first-match     Choose first partial station name match
    --gui                 Disable ncurses interface, run VLC in GUI mode
    --write-shell-script  Write a shell script that sets up environment and
                          executes vlc-radio
    --version             Print version string and exit
  ```

  If you just run 'vlc-radio', you get a selection menu of what station to play:
  ![Chill Streams](https://github.com/zcutlip/chill_streams/raw/main/images/radio-menu.png)

  But, if you already know what station you want, you can ask for it directly:
  ![Play station 8](https://github.com/zcutlip/chill_streams/raw/main/images/vlc-radio-8.gif)

  If you know the name or partial name of a station, you can ask for it. If the match isn't ambiguous, `vlc` will play the station directly. If it *i*s ambiguous, you'll get a reduced selection list:

  ![Groove Salad?](https://github.com/zcutlip/chill_streams/raw/main/images/vlc-radio-groovesalad.gif)

  Note that case and whitespace is ignored when asking for a station, so "DEF CON" and "defcon" are equivalent.

  If you just want the first match (e.g., "groove salad" not "groove salad classic"), use the `-f` or `--first-match` option:

  ![first match](https://github.com/zcutlip/chill_streams/raw/main/images/vlc-radio-groovesalad-first-match.gif)



  You can use the `--write-shell-script` option to write a shell script that will boostrap `vlc-radio` for use in minimal environments. This is useful, for example, to create a dedicated terminal profile that just runs `vlc-radio` with specific station. Since no shell gets initialized, `$PATH` may not be set, and the location of VLC may not be known.

  Below is such a profile in iTerm2:

  ![iTerm2 dedicated profile](https://github.com/zcutlip/chill_streams/raw/main/images/iterm2-profiles.png)



  Thanks to [nick3499](https://github.com/nick3499) for the [original project](https://github.com/nick3499/radio_streams_vlc) this is forked from, and for curating a comprehensive directory of shoutcast stations.


pkgId: f6510d589e7b350550780688272cf9e0417d5693684f007e76bfb6177aa7a7af
name: python-Choam
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Python project scaffolder/manager
url: https://pypi.org/project/Choam/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Choam-1.0.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pepy.tech/project/choam"><img src="https://img.shields.io/pypi/dw/choam"></a>
  <a href="https://pypi.org/project/choam"><img src="https://img.shields.io/pypi/v/choam"></a>
  <a href="https://github.com/cowboycodr/choam"><img alt="LOC" src="https://shields.io/tokei/lines/github/cowboycodr/choam"></a>
  <a href="https://github.com/cowboycodr/choam"><img src="https://img.shields.io/github/repo-size/cowboycodr/choam"></a>

  Python enviroment manager based around making depedency management, and publication easier.

  While Python is a simple langauge all-around, managing dependencies and publication aren't. However, Choam automates this, with easy configuration, and simple commands.

  > Choam, automating the nooks and crannies of Python.


  Choam is currently in beta. If you are not comfortable with this, then use a different dependency manager in the meantime like `poetry`.


  `$ pip install choam`


  The most useful snippets of `Choam`

  > Note: Depending on your system's configurations, Choam might have to be prefixed with `$ python3 -m` like this, `$ python3 -m choam <COMMAND>`



  `$ choam new <project_name>`


  `$ choam init <optional: --adapt (adapts the current project to choam's standards)>`


  `$ choam add <dependency_name>`


  `$ choam install`


  `$ choam deps`


  `$ choam reqs`


  `$ choam setup`


  `$ choam publish`


  `$ choam run <filepath_or_script> <optional: --file (to run files instead of scripts)>`
  ___


  ```toml

  [package]
  name = "choam"
  version = "0.0.0"
  description = "Choam is a project manager"
  repo = "https://github.com/cowboycodr/choam"
  keywords = ["manager"]
  ```

  So far we've described the package metadata. Including the package name, version, description, and other useful information. This will all be setup when you setup the project with Choam.


  Managing dependencies with Choam is just as easy as defining the package metadata.
  ```toml

  [package]
  ...

  [modules]
  choam = "*"
  ```

  The `*` means it will require the lastest version of the specified module. You can sepcify specific versions if you like: `choam = "0.1.18""`
  ___
  Since Choam is in beta, it will sometimes capture unwanted depedencies. To by-pass this behavior define a `[modules-ignore]` section. Like so:
  ```toml

  [package]
  ...

  [modules]
  ...

  [modules-ignore]
  shutil = "*"
  ```
  `toml` is a weird configuration langauge so make sure to include the ` = "*"` after the specified package.
  ___



  To add custom defined scripts to your project all that is required is `[script.<YOUR_SCRIPT_NAME>]` and a few other parameters. Let's make a format script with python's black, for example.
  ```toml

  [package]
  ...

  [modules]
  ...

  [modules-ignore]
  ...

  [script.format]
  requires = ["black"]
  perspective = "${PROJECT}"
  command = "${PYTHON} -m black ."
  ```

  The `requires` section defines what dependencies are used with the script.

  The `perspective` parameter defines where the script will run relative to the project folder. The `${PROJECT}` will run in the project files directory instead of the overall project folder where the `Choam.toml`, `README.md` etc. are.

  > Note: notice how `${PROJECT}` is used? When a piece of text is wrapped like `${}` this means it is a script variable. Choam provides multiple script variables such as `${PYTHON}` to access the active python interpreter, `${CWD}` to access the current directory, and `${PROJECT}` which is the current working directory. With these script variables you can create very useful scripts that work on any machine.

  The `perspective` parameter defines the actual command that will be run.

  Combining all of these with script variables you can create dynmaic, cross-platform, useful, scripts available to anyone.

  Running the script:

  `$ choam run format`

  In result this will format all of your project files



  The `.choam` folder is specifically for storing Choam related resources. For example: if you have a choam script, and you need to pull from a file, for example. You would put the resource in `.choam/scripts/<SCRIPT_NAME>/<FILE>`


pkgId: 30998edbc2c78acabe492012f961834859c4b4a71facdb02934089e0b49d1860
name: python-Chozita
arch: src
version: 1.5.7
epoch: 0
release: 1
summary: Una mini librería de automatización de cifrado de archivos
url: https://github.com/BAA4TS/Chozita
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chozita-1.5.7-1.src.rpm
checksum_type: sha256
description:
  Chozita es una mini librería para encriptar y desencriptar archivos utilizando Fernet como intermediario.

  ![Imagen de GitHub](github/wallgit.jpg)

  ![License](https://img.shields.io/badge/license-MIT-green) ![Version](https://img.shields.io/badge/version-1.4.1-green) ![Python](https://img.shields.io/badge/python-green?logo=python) ![Fernet](https://img.shields.io/badge/fernet-encryption-green?logo=shield&style=flat)


  El objetivo de Chozita es simplificar el proceso de encriptar archivos para marcos de trabajo como Tkinter.


  Actualmente, cuenta con dos funciones básicas para trabajar (`cifrar` y `descifrar`). Estas son las implementaciones iniciales de la librería. En futuras versiones, se añadirán más métodos, como la capacidad de distribuir el contenido cifrado en múltiples archivos JSON en lugar de uno solo, y la implementación de compresión ZIP.


  ```bash
  pip install Chozita
  ```


  El cifrado se realizará como en el formato actual, pero el contenido estará distribuido en múltiples archivos dentro de un archivo ZIP. La función se encargará directamente de descomprimir y leer los archivos internos para descifrarlos y recrear el contenido original.


  * La biblioteca maneja automáticamente los `PATH`. Si se indica cifrar un archivo, por ejemplo: `src/img.jpg`, el archivo JSON que contiene los datos cifrados se creará automáticamente en el mismo `PATH` con el nombre `src/img.json`. Lo mismo ocurre para ambas funciones de cifrado.

  * Las funciones que empiezan con doble guion bajo ( __ ) no son para el uso del usuario; son funciones internas del código.



  Las funciones devuelven una tupla de datos `[bool, string]`:
  - `bool` devuelve `True` si se ejecutó correctamente y `False` si hubo algún error.
  - `string` permanece vacío si todo funciona correctamente, pero contiene el mensaje de error si `bool` es `False`.

  ```python
  from Chozita import Chozita


  C = Chozita()


  CheckValue, ErrorString = C.cifrar('img.jpg', 'password')
  if not CheckValue:
      print(ErrorString)

  CheckValue, ErrorString = C.descifrar('img.json', 'password')
  if not CheckValue:
      print(ErrorString)


  CheckValue, ErrorString = C.cifrar('src/img.jpg', 'password')
  if not CheckValue:
      print(ErrorString)

  CheckValue, ErrorString = C.descifrar('src/img.json', 'password')
  if not CheckValue:
      print(ErrorString)
  ```


pkgId: 4875f1503e98bd787ac5cd9a599cb7ebfdad06307ebb66585d5db3d6e1bb9255
name: python-ChromaStyler
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: none
url: https://pypi.org/project/ChromaStyler/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChromaStyler-1.1.0-1.src.rpm
checksum_type: sha256
description:
  To install the package, use `pip`:

  ```bash
  pip install ChromaStyler
  ```

   a library to get colors in python.
   use this library to make output colored!

   this library have three diferent parts: color, style, back
   
    to use this library for text color, you can import color or use it directly:
     ```bash
     import ChromaStyler
     ```
     or
     ```bash
     from ChromaStyler import color
     ```
    to use color, just enter what color do you want:
     ```bash
     blue = color.blue \# Or ChromaStyler.style.bold if tou use import ChromaStyler
     print(blue + 'hello this is a blue text')
     ```
   
    to use this library for font style, you can import style or use it directly:
     ```bash
     import ChromaStyler
     ```
     or
     ```bash
     from ChromaStyler import style
     ```
    to use style, just enter what style do you want:
     ```bash
     bold = style.bold \# Or ChromaStyler.style.bold if tou use import ChromaStyler
     print(bold + 'hello this is a bold text')
     ```
   
    to use this library for background color, you can import style or use it directly:
     ```bash
     import ChromaStyler
     ```
     or
     ```bash
     from ChromaStyler import back
     ```
    to use style, just enter what style do you want:
     ```bash
     bold = back.purple \# Or ChromaStyler.style.bold if tou use import ChromaStyler
     print(purple + 'hello this is a normal text with purple background')
     ```


pkgId: f3fcc0fbc0d9a979b2044ec6cfbb9268c73e83aee7bdaef761bb43683328f98a
name: python-ChromeController
arch: src
version: 0.3.26
epoch: 0
release: 1
summary: Chrome Remote Debugger interface.
url: https://github.com/fake-name/ChromeController
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChromeController-0.3.26-1.src.rpm
checksum_type: sha256
description:
  Current Usage so far has been basically to find bugs or strangeness in the
  chromium remote debug interface:
   - Strange Behaviour is `network.getCookies` (fixed)
       https://bugs.chromium.org/p/chromium/issues/detail?id=668932
   - `network.clearBrowserCookies` appears to have no effect (fixed)
       https://bugs.chromium.org/p/chromium/issues/detail?id=672744
   - General header issues in the devtools interface:
       https://bugs.chromium.org/p/chromium/issues/detail?id=849972


pkgId: ee50308f3af4af47604077c4643bd7b26abd3c5139457b546571795c711ad96b
name: python-Chronix2Grid
arch: src
version: 1.2.0.post1
epoch: 0
release: 1
summary: A python package to generate "en-masse" chronics for loads and productions (thermal, renewable)
url: https://github.com/BDonnot/ChroniX2Grid
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Chronix2Grid-1.2.0.post1-1.src.rpm
checksum_type: sha256
description:
  Chronix2Grid is a python package, providing a command-line application as well,
  that allows to generate synthetic but realistic consumption, renewable production, electricity loss (dissipation)
  and economic dispatched productions chronics given a power grid.
  Reference data that you provide will serve to calibrate the parameters
  so that the synthetic data reproduce some realistic criteria (KPIs) from the reference data.

  *   [1 Chronix2Grid at a glance](#glance)
  *   [2 Installation](#installation)
  *   [3 Getting Started](#getting-started)
  *   [4 The command-line interface](#the-command-line-interface)
  *   [5 Configuration](#configuration)
  *   [6 Running the test suite](#running-the-test-suite)

  See the documentation at https://chronix2grid.readthedocs.io/en/latest/


  ![Chronix2grid_inputs](pictures/ChroniX2Grid_inputs.png "Chronix2Grid Inputs")

  ![Chronix2grid_outputs](pictures/ChroniX2Grid_ouputs.png "Chronix2Grid Ouputs")




  *   Python >= 3.6


  ```commandline
  pip3 install -U virtualenv
  python3 -m virtualenv venv_chronix2grid
  ```


  ```commandline
  source venv_chronix2grid/bin/activate
  pip install Chronix2Grid
  ```


  ```commandline
  source venv_chronix2grid/bin/activate
  git clone https://github.com/mjothy/ChroniX2Grid.git
  cd ChroniX2Grid/
  pip install -U .
  ```



  A backend for dispatch has been implemented with PyPSA

   ```commandline
  pip install pypsa==0.17.0
  ```
  You might need to install cbc solver as well that pypsa will call: https://projects.coin-or.org/Cbc


  Four notebooks are provided to get you started with this package:

  * **getting_started_cli.ipynb** guide you through the use of chronix2grid cli
  * **getting_started_api.ipynb** is a more detailed notebook that presents chronix2grid api and showcases several ways to
   analyze the chronics produced
  * **running_chronics_grid2op.ipynb** is a notebook giving an example of how generated chronics can further be used to create power grid scenarios and run them
   analyze the chronics produced
  * **RenewableNinja_Solar_WInd_KPI_format.ipynb** is an example on how to retrieve Solar and Wind reference chronics from the
    [renewable ninja](https://www.renewables.ninja/) api. There will be use to compare the KPI's with the generated chronics.

  Additionally, a data starting kit is provided to run an example in the folder
    ```commandline
  getting_started/example
  ```
   The output folder corresponds to the following run of chronix2grid :
   ```commandline
  chronix2grid --mode LRTK --ignore-warnings --weeks 8 --n_scenarios 1 --start-date 2012-01-01 --by-n-weeks 4
  ```

  NB:
  * Default input data from package will be used if no --input-data and --case is provided
  * Output will be written in the working directory in a folder output/

  To provide --input-data and --output-folder folders and specify --case grid case, you would run this kind of command (make sure to change ChroniX2Grid_path with you own path) :
   ```commandline
  chronix2grid --mode RLTK --output-folder ChroniX2Grid_path/getting_started/example/output --input-folder ChroniX2Grid_path/getting_started/example/input --ignore-warnings --weeks 8 --case case118_l2rpn_wcci --n_scenarios 1 --start-date 2012-01-01 --by-n-weeks 4
  ```


  In order to limit the size of the output and the running time for this example, chronics are only generated for 8 weeks.
  This implicates that some kpis that defined on a whole year will not be exploitable for this example.


  ```commandline
  Usage: chronix2grid [OPTIONS]

  Options:
    --case TEXT               case folder to base generation on
    --start-date TEXT         Start date to generate chronics
    --weeks INTEGER           Number of weeks to generate
    --by-n-weeks INTEGER      Size of the output chunks in weeks
    --n_scenarios INTEGER     Number of scenarios to generate
    --mode TEXT               Steps to execute : L(K) for loads only (and KPI);
                              R(K) for renewables (and KPI) only; LRT (K)
                              for load, renewable and thermic generation (and KPI);
                              LRDT(TK) for load, renewable, loss (dissipation) generation
                              (and thermic and KPI)

    --input-folder TEXT       Directory to read input files from.
    --output-folder TEXT      Directory to store output files.
    --seed-for-loads TEXT     Input seed to ensure reproducibility of loads
                              generation

    --seed-for-res TEXT       Input seed to ensure reproducibility of renewables
                              generation

    --seed-for-dispatch TEXT  Input seed to ensure reproducibility of dispatch
    --ignore-warnings         Ignore the warnings related to the existence of
                              data files in the chosen output directory.

    --scenario_name TEXT      subname to add to the generated scenario output
                              folder, as Scenario_subname_i

    --nb_core INTEGER         number of cores to parallelize the number of
                              scenarios

    --help                    Show this message and exit.

  ```


  4 generation submodules and a KPI module are available

  * L - load generation
  * R - wind and solar production generation
  * D - loss generation a priori, that will be used for dispatch and potentially corrected afterwards
  * T - thermic and hydro production generation thanks to an economic dispatch (simplified optimal power flow simulation)
  * K - KPI generation in order to compare synthetic (generated) chronics to reference (real-life) chronics

  The figure below shows how these submodules can be launched together with --mode/-m argument.
  Note that D and T submodules can't be launched without previous L and R modules, and that KPIs can always been computed

  ![Launch_mode](pictures/Launch_mode.png "Launch mode")




  Detailed configuration is made through thematic json files.
  For instance you will use in the current implementation of Chronix2grid:

  * **params.json** for general generation configuration (generation timestep, noise for forecast chronics)
  * **params_load.json** for load generation
  * **params_res.json** for solar and wind generation. You will use paramsGAN.json in case you are using the backend with Generative Adversarial Networks
  * **params_loss.json** for a priori loss generation
  * **params_opf.json** for dispatch and a posteriori loss simulation

  Below is an example of **params.json** which will launch a 5 minutes time step generation,
  applying a gaussian noise to forecast chronics with a standard deviation of 0.01
  ```json
  {
    "dt": 5,
    "planned_std": "0.01"
  }
  ```

  Below is an example of **params_load.json** that provides parameters to correlated generation algorithm.

  ```json
  {
    "Lx": 1000,
    "Ly": 1000,
    "dx_corr": 250,
    "dy_corr": 250,
    "temperature_corr": 400,
    "std_temperature_noise": 0.06
  }
  ```

  You'll find all the details on the parameters used in these json files in the [documentation about implemented models](https://chronix2grid.readthedocs.io/en/latest/DESCRIPTION.html)


  Some general parameters have to be set in *INPUT_FOLDER/kpi/paramsKPI.json*
  - **comparison**: name of benchmark folder to use for KPI reference chronics. For example, benchmark *France* has been implemented with eco2mix and renewable ninja data
  - **timestep**: timestep for KPI computation. For example, renewable ninja data requires minimum timestep of 60min
  - **night_hours**: dictionary to provide night hours for each season of year
  - **seasons**: dictionary to provide months in each season of year



  All generation submodules (LRDT) have a modular backend.
  You can develop your own load, renewable, loss and dispatch model using as input:
  * Your json parameters
  * Possible pattern files, or trained neural networks
  * Grid demand and generator characteristics in csv


  ```
  @misc{chronix2grid,
      author = {A. Marot, N. Megel, V. Renault, M. Jothy },
      title = {{ChroniX2Grid - The Extensive PowerGrid Time-serie Generator}},
      year = {2020},
      publisher = {GitHub},
      journal = {GitHub repository},
      howpublished = {\url{https://github.com/BDonnot/ChroniX2Grid}},
      }
  ```


  To launch the unit test suite:
  ```commandline
  pipenv run python -m pytest tests/unit_tests/ [--verbose -p no:warnings]
  ```

  To launch integration tests:
  ```commandline
  pipenv run python -m pytest tests/integration_tests/ [--verbose -p no:warnings]
  ```

  To launch the Command Line Interface (CLI) test (only if you installed chronix2grid package from Pypi)
  ```commandline
  pipenv run python -m pytest tests/cli_tests/
  ```

  You can also analyse the coverage of the tests with coverage and generate an html report:
  ```commandline
  pip install coverage
  coverage run --source=./chronix2grid -m unittest discover
  coverage html
  ```
  This will generate a htmlcov folder containing a static web site with the analysis. Open index.html in a browser
   to analyse it.


pkgId: 183552e8a8cfebf39616ecaa92cc699dc4c01f54a97cb12e892fbe1893be57b3
name: python-ChurchToolsApi
arch: src
version: 0.0.2rc83.post1
epoch: 0
release: 1
summary: A Python wrapper for the ChurchTools API
url: https://pypi.org/project/ChurchToolsApi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ChurchToolsApi-0.0.2rc83.post1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://codecov.io/gh/2000game/ChurchToolsApi/branch/main/graph/badge.svg
      :target: https://codecov.io/gh/2000game/ChurchToolsApi
      :alt: Codecov



  This project is a template for creating Python projects that follows the Python Standards declared in PEP 621. It uses a pyproject.yaml file to configure the project and Flit to simplify the build process and publish to PyPI. Flit simplifies the build and packaging process for Python projects by eliminating the need for separate setup.py and setup.cfg files. With Flit, you can manage all relevant configurations within the pyproject.toml file, streamlining development and promoting maintainability by centralizing project metadata, dependencies, and build specifications in one place.



  - `.github/workflows`: Contains GitHub Actions used for building, testing, and publishing.
  - `.devcontainer/Dockerfile`: Contains Dockerfile to build a development container for VSCode with all the necessary extensions for Python development installed.
  - `.devcontainer/devcontainer.json`: Contains the configuration for the development container for VSCode, including the Docker image to use, any additional VSCode extensions to install, and whether or not to mount the project directory into the container.
  - `.vscode/settings.json`: Contains VSCode settings specific to the project, such as the Python interpreter to use and the maximum line length for auto-formatting.
  - `src`: Place new source code here.
  - `tests`: Contains Python-based test cases to validate source code.
  - `pyproject.toml`: Contains metadata about the project and configurations for additional tools used to format, lint, type-check, and analyze Python code.



  The pyproject.toml file is a centralized configuration file for modern Python projects. It streamlines the development process by managing project metadata, dependencies, and development tool configurations in a single, structured file. This approach ensures consistency and maintainability, simplifying project setup and enabling developers to focus on writing quality code. Key components include project metadata, required and optional dependencies, development tool configurations (e.g., linters, formatters, and test runners), and build system specifications.

  In this particular pyproject.toml file, the [build-system] section specifies that the Flit package should be used to build the project. The [project] section provides metadata about the project, such as the name, description, authors, and classifiers. The [project.optional-dependencies] section lists optional dependencies, like pyspark, while the [project.urls] section supplies URLs for project documentation, source code, and issue tracking.

  The file also contains various configuration sections for different tools, including bandit, black, coverage, flake8, pyright, pytest, tox, and pylint. These sections specify settings for each tool, such as the maximum line length for flake8 and the minimum code coverage percentage for coverage.





  Black is a Python code formatter that automatically reformats Python code to conform to the PEP 8 style guide. It is used to maintain a consistent code style throughout the project.

  The pyproject.toml file specifies the maximum line length and whether or not to use a "fast" mode for formatting. Black also allows for a pyproject.toml configuration file to be included in the project directory to customize its behavior.



  Coverage is a tool for measuring code coverage during testing. It generates a report of which lines of code were executed during testing and which were not.

  The pyproject.toml file specifies that branch coverage should be measured and that the tests should fail if the coverage falls below 100%. Coverage can be integrated with a variety of test frameworks, including pytest.



  Pytest is a versatile testing framework for Python projects that simplifies test case creation and execution. It supports both pytest-style and unittest-style tests, offering flexibility in testing approaches. Key features include fixture support for clean test environments, parameterized tests to reduce code duplication, and extensibility through plugins for customization. Adopt pytest to streamline testing and tailor the framework to your project's specific needs.

  The pyproject.toml file plays an essential role in configuring pytest for your project. It includes various test markers, such as integration, notebooks, gpu, spark, slow, and unit, which are used during testing. It also specifies options for generating test coverage reports, setting the Python path, and outputting test results in the xunit2 format. You can easily modify the pyproject.toml file to customize pytest for your project's specific needs.


  Pylint is a versatile Python linter and static analysis tool that identifies errors and style issues in your code. It generates an in-depth report, presenting errors, warnings, and conventions found in the codebase. Pylint configurations are centralized in the pyproject.toml file, covering extension management, warning suppression, output formatting, and code style settings such as maximum function arguments and class attributes. The unique scoring system provided by Pylint helps developers assess and maintain code quality, ensuring a focus on readability and maintainability throughout the project's development.


  Pyright is a static type checker for Python that uses type annotations to analyze your code and catch type-related errors. It is capable of analyzing Python code that uses type annotations as well as code that uses docstrings to specify types.

  The pyproject.toml file contains configurations for Pyright, such as the directories to include or exclude from analysis, the virtual environment to use, and various settings for reporting missing imports and type stubs. By using Pyright, you can catch errors related to type mismatches before they even occur, which can save you time and improve the quality of your code.


  Flake8 is a code linter for Python that checks your code for style and syntax issues. It checks your code for PEP 8 style guide violations, syntax errors, and more.

  The pyproject.toml file contains configurations for Flake8, such as the maximum line length, which errors to ignore, and which style guide to follow. By using Flake8, you can ensure that your code follows the recommended style guide and catch syntax errors before they cause problems.


  In our repository, we use Tox to automate testing and building our Python package across various environments and versions. Configured through the pyproject.toml file, Tox is set up with four testing environments: py, integration, spark, and all. Each environment targets specific test categories or runs all tests together, ensuring compatibility and functionality in different scenarios.

  The [tool.tox] section in the pyproject.toml file contains the Tox configuration details, including the legacy_tox_ini attribute. Our setup outlines the dependencies needed for each environment, as well as the test runner (e.g., pytest) and any associated commands. This ensures consistent test execution across all environments.

  Tox helps us efficiently automate testing and building processes, maintaining the reliability and functionality of our Python package across a wide range of environments. By identifying potential compatibility issues early in the development process, we improve the quality and usability of our package. Our Tox configuration streamlines the development workflow, promoting code quality and consistency throughout the project.



  In our project, we use GitHub Codespaces to simplify development and enhance collaboration. Codespaces provides a consistent, cloud-based workspace accessible from any device with a web browser, eliminating the need for local software installations. Our configuration automatically sets up required dependencies and development tools, while customizable workspaces and seamless GitHub integration streamline the development process and improve teamwork.

  When you create a Codespace from a template repository, you initially work within the browser version of Visual Studio Code. Or, connect your local VS Code to a remote Codespace and enjoy seamless development without the hassle of local software installations. GitHub now supports this fantastic feature, making it a breeze to work on projects from any device.

  To get started, simply set the desktop version of Visual Studio Code as your default editor in GitHub account settings. Then, connect to your remote Codespace from within VS Code, and watch as your development process is revolutionized! With Codespaces, you'll benefit from the consistency and flexibility of a cloud-based workspace while retaining the comfort of your local editor. Say hello to the future of development!

  GitHub Codespaces also supports Settings Sync, a feature that synchronizes extensions, settings, and preferences across multiple devices and instances of Visual Studio Code. Whether Settings Sync is enabled by default in a Codespace depends on your pre-existing settings and whether you access the Codespace via the browser or the desktop application. With Settings Sync, you can ensure a consistent development experience across devices, making it even more convenient to work on your projects within GitHub Codespaces.


  Dev Containers in Visual Studio Code allows you to use a Docker container as a complete development environment, opening any folder or repository inside a container and taking advantage of all of VS Code's features. A devcontainer.json file in your project describes how VS Code should access or create a development container with a well-defined tool and runtime stack. You can use an image as a starting point for your devcontainer.json. An image is like a mini-disk drive with various tools and an operating system pre-installed. You can pull images from a container registry, which is a collection of repositories that store images.

  Creating a dev container in VS Code involves creating a devcontainer.json file that specifies how VS Code should start the container and what actions to take after it connects. You can customize the dev container by using a Dockerfile to install new software or make other changes that persist across sessions. Additional dev container configuration is also possible, including installing additional tools, automatically installing extensions, forwarding or publishing additional ports, setting runtime arguments, reusing or extending your existing Docker Compose setup, and adding more advanced container configuration.

  After any changes are made, you must build your dev container to ensure changes take effect. Once your dev container is functional, you can connect to and start developing within it. If the predefined container configuration does not meet your needs, you can also attach to an already running container instead. If you want to install additional software in your dev container, you can use the integrated terminal in VS Code and execute any command against the OS inside the container.

  When editing the contents of the .devcontainer folder, you'll need to rebuild for changes to take effect. You can use the Dev Containers: Rebuild Container command for your container to update. However, if you rebuild the container, you will have to reinstall anything you've installed manually. To avoid this problem, you can use the postCreateCommand property in devcontainer.json. There is also a postStartCommand that executes every time the container starts.

  You can also use a Dockerfile to automate dev container creation. In your Dockerfile, use FROM to designate the image, and the RUN instruction to install any software. You can use && to string together multiple commands. If you don't want to create a devcontainer.json by hand, you can select the Dev Containers: Add Dev Container Configuration Files... command from the Command Palette (F1) to add the needed files to your project as a starting point, which you can further customize for your needs.


  This project includes three files in the .devcontainer and .vscode directories that enable you to use GitHub Codespaces or Docker and VSCode locally to set up an environment that includes all the necessary extensions and tools for Python development.

  The Dockerfile specifies the base image and dependencies needed for the development container. The Dockerfile installs the necessary dependencies for the development container, including Python 3 and flit, a tool used to build and publish Python packages. It sets an environment variable to indicate that flit should be installed globally. It then copies the pyproject.toml file into the container and creates an empty README.md file. It creates a directory src/python_package and installs only the development dependencies using flit. Finally, it removes unnecessary files, including the pyproject.toml, README.md, and src directory.

  The devcontainer.json file is a configuration file that defines the development container's settings, including the Docker image to use, any additional VSCode extensions to install, and whether or not to mount the project directory into the container. It uses the python-3-miniconda container as its base, which is provided by Microsoft, and also includes customizations for VSCode, such as recommended extensions for Python development and specific settings for those extensions. In addition to the above, the settings.json file also contains a handy command that can automatically install pre-commit hooks. These hooks can help ensure the quality of the code before it's committed to the repository, improving the overall codebase and making collaboration easier.

  The settings.json file is where we can customize various project-specific settings within VSCode. These settings can include auto-formatting options, auto-trimming of trailing whitespace, Git auto-fetching, and much more. By modifying this file, you can tailor the VSCode environment to your specific preferences and workflow. It also contains specific settings for Python, such as the default interpreter to use, the formatting provider, and whether to enable unittest or pytest. Additionally, it includes arguments for various tools such as Pylint, Black, Flake8, and Isort, which are specified in the pyproject.toml file.



  To get started with this template, simply 'Use This Template' to create a new repository and start building your project within the `src` directory. Try to open the project in GitHub Codespace, and to run the unit tests using the VS Code Test extension.



  This project welcomes contributions and suggestions. For details, visit the repository's [Contributor License Agreement (CLA)](https://cla.opensource.microsoft.com) and [Code of Conduct](https://opensource.microsoft.com/codeofconduct/) pages.


  Available types:
   - feat: A new feature
   - fix: A bug fix
   - docs: Documentation only changes
   - style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
   - refactor: A code change that neither fixes a bug nor adds a feature
   - perf: A code change that improves performance
   - test: Adding missing tests or correcting existing tests
   - build: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
   - ci: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
   - chore: Other changes that don't modify src or test files
   - revert: Reverts a previous commit


pkgId: 4f12b6576e87267ea99c99a4cef1b0eaeefb582d5b4da6b98efeaa33ccbc99ea
name: python-CipherSmith
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A powerful password generator with real-time strength analysis
url: https://github.com/amulthantharate/CipherSmith
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CipherSmith-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/CipherSmith.svg)](https://badge.fury.io/py/CipherSmith)
  [![Python Versions](https://img.shields.io/pypi/pyversions/CipherSmith.svg)](https://pypi.org/project/CipherSmith/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  A powerful CLI password generator with real-time strength analysis and advanced security features. Built with security and usability in mind! 🚀



  - 🎯 Generate cryptographically secure passwords
  - 📊 Real-time password strength analysis using zxcvbn
  - 🔍 Detailed password security feedback and suggestions
  - 📝 Password history tracking with tags and descriptions
  - 🔎 Search through password history
  - 📈 Password generation statistics
  - 🎨 Exclude similar characters option
  - 🛡️ Advanced pattern detection and security analysis





  - Python 3.9 or higher
  - pip (Python package installer)



  ```bash
  pip install CipherSmith
  ```



  ```bash

  CipherSmith generate


  CipherSmith generate --uppercase 2 --lowercase 6 --numbers 2 --special-chars 2


  CipherSmith check "your-password-here"


  CipherSmith check "your-password-here" --verbose


  CipherSmith history


  CipherSmith search "github"
  ```



  CipherSmith includes advanced password strength analysis:

  - Real-time strength visualization
  - Pattern detection
  - Crack time estimation
  - Security suggestions
  - Comprehensive feedback

  Example output:
  ```
  Password Strength Analysis:
  Score: 4/4
  Crack Time: 1961.20 seconds
  Feedback: Strong password!

  Additional Details:
  Length: 18
  Character Sets: lowercase, uppercase, numbers, special
  Patterns Found: None
  Suggestions: None
  ```



  For detailed usage examples, see our [Demo Guide](DEMO.md).

  Common topics:
  - [Installation Guide](INSTALL.md)
  - [Usage Examples](DEMO.md)
  - [Changelog](CHANGELOG.md)



  - typer>=0.9.0
  - rich>=10.0.0
  - zxcvbn-python>=4.4.24
  - cryptography>=41.0.0
  - sqlalchemy>=2.0.0
  - click>=8.0.0
  - colorama>=0.4.4



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  Amul Thantharate (amulthantharate@gmail.com)



  Current version: 1.2.0


pkgId: c12b735b2a0a2a008cb7bc1f8c69752ece377ca38a22a19a8fd972b1103ad6eb
name: python-CircuitCalculator
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Library for analysing and calculating electric networks.
url: https://pypi.org/project/CircuitCalculator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CircuitCalculator-0.4.2-1.src.rpm
checksum_type: sha256
description:
  This project is a simple calculator for electrical circuits. It allows users to input the values of various components in a circuit (such as resistors, capacitors, and voltage sources) and will then calculate various properties of the circuit, such as the current and voltage at different points.



  To use this calculator, there are different interfaces. The most convenient one is to use the `SimpleCircuit` module, which is based somehow on the [schemdraw](https://schemdraw.readthedocs.io/en/latest/) package. There are several IPython notebook examples can be found [here](examples/examples.md).



  Currently, the following components are supported:

  - Resistors
  - Capacitors
  - Voltage sources
  - Current sources



  This project is open-source and contributions are welcome. If you would like to contribute, please fork the repository and make a pull request.



  This project is licensed under the MIT License.



  If you have any questions or issues, please open an issue on the GitHub repository.


pkgId: 5babc95da4cadd171d5537ea7a0b563b13812a07e797c975272bb4afadc3cfd5
name: python-Cirron
arch: src
version: 0.4
epoch: 0
release: 1
summary: Cirron measures how many CPU instructions and system calls a piece of Python code executes.
url: https://github.com/s7nfo/Cirron
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cirron-0.4-1.src.rpm
checksum_type: sha256
description:
  Cirron measures a piece of Python code and report back several performance counters: CPU instruction count, branch misses, page faults and time spent measuring. It uses the Linux perf events interface or @ibireme's [KPC demo](https://gist.github.com/ibireme/173517c208c7dc333ba962c1f0d67d12) on OSX.

  It can also trace and modify syscalls using `strace`, Linux only!



  - Linux with perf events support / Apple ARM OSX
  - C++
  - Python 3.x





  ```bash
  pip install cirron
  ```

  The wrapper automatically compiles the C++ library (cirronlib.cpp) on first use.





  ```
  $ sudo python
  >>> from cirron import Collector
  >>>
  >>> # Start collecting performance metrics
  >>> with Collector() as collector:
  >>>     # Your code here
  >>>     print("Hello")
  >>>
  >>> # Retrieve the metrics
  >>> print(collector.counters)
  Counter(time_enabled_ns=144185, instruction_count=19434, branch_misses=440, page_faults=0)
  ```



  ```
  $ sudo python
  >>> from cirron import Tracer, to_tef

  >>> with Tracer() as tracer:
  >>>     # Your code here
  >>>     print("Hello")
  >>>
  >>> # Retrieve the trace
  >>> print(tracer.trace)
  >>> [Syscall(name='write', args='1, "Hello\\n", 6', retval='6', duration='0.000043', timestamp='1720333364.368337', pid='2270837')]
  >>>
  >>> # Save the trace for ingesting to Perfetto
  >>> open("/tmp/trace", "w").write(to_tef(tracer.trace))
  ```



  Available tampering actions are:
  `error`: Inject a fault with the specified errno.
  `retval`: Inject a success with the specified return value.
  `signal`: Deliver the specified signal on syscall entry.
  `delay_enter`: Delay syscall entry by the specified time.
  `delay_exit`: Delay syscall exit by the specified time.
  `poke_enter`: Modify memory at argN on syscall entry.
  `poke_exit`: Modify memory at argN on syscall exit.
  `syscall`: Inject a different syscall instead.

  The `when` argument can be used to specify when to perform the tampering.

  See the Tampering section of the [strace manual page](https://man7.org/linux/man-pages/man1/strace.1.html) for more detailed explanaition of the arguments.

  ```
  $ sudo python
  >>> from cirron import Injector

  >>> injector = Injector()
  >>> injector.inject("openat", "error", "ENOSPC")
  >>> injector.inject("openat", "delay_enter", "1s", when="2+2")
  >>> with injector:
  >>>     # Open now fails with "No space left on device" and every
  >>>     # other call to `openat` will be delayed by 1s.
  >>>     f = open("test.txt", "w")
  ```


pkgId: a38b9cb1805021e2db9cf452155e4c314109966209e375a1f744abb55625c990
name: python-Cities
arch: src
version: 1.1
epoch: 0
release: 1
summary: Cities is a simple tool for searching cities located at a given longitude and latitude range.
url: https://github.com/131250208/Cities
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cities-1.1-1.src.rpm
checksum_type: sha256
description:
  Cities is a simple tool for searching cities located at a given longitude and latitude range or a given region(country, state, province).
  All the cities returned are sorted by the importance of a city and the population density.


  ```commandline
  pip install Cities
  ```


  1. fast(less than 0.01s for each retrieving), simple and convenient.
  2. cover all the cities around the world.
  3. the author is cute.


  Download  the [city data](https://pan.baidu.com/s/10qjtq9jl7tLxXeypfJCrEg) and put it at any directory you want. Remember to set the path up when you initiate an instance.


  ```python
  from Cities import cities_retriever

  cr = cities_retriever.CitiesRetrieverByRect("Sources/dict_all_cities_rect2cities.json")
  cities = cr.retrieve_cities(lon_start=-124.71, lon_end=-77.21, lat_start=25.24, lat_end=44.75, num=500) # num is optional, default: 999999
  print(cities)
  print(len(cities))

  cr = cities_retriever.CitiesRetrieverByRegionName("Sources/dict_all_cities_region2cities.json")
  cities = cr.retrieve_cities(country="United States", region="Washington", num=500) # region and num are optional
  print(cities)
  print(len(cities))
  ```

  the bigger the dict file is, the longer the loading time is.

  1. dict_all_cities_region2cities.json
  2. dict_all_cities_rect2cities.json

  1. dict_cities_8000_region2cities.json
  2. dict_cities_8000_rect2cities.json


pkgId: a262e67ebf82e3e09ea94b3ea8fe651cb952bd34f60ec740389b5bdd4932f283
name: python-CityAD
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: CityAD, an Automatic Differentiation package
url: https://github.com/cityscape-107/cs107-FinalProject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CityAD-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Automatic Differentiation, or Algorithmic Differentiation, is a term used to describe a collection of techniques that can be used to calculate the derivatives of complicated functions. Because derivatives play a key role in computational analyses, statistics, and machine and deep learning algorithms, the ability to quickly and efficiently take derivatives is a crucial one. Other methods for taking derivatives, however, including Finite Differentiation and Symbolic Differentiation have drawbacks, including extreme slowness, precision errors, inaccurate in high dimensions, and memory intensivity.  Automatic differentiation addresses many of these concerns by providing an exact, high-speed, and highly-applicable method to calculate derivatives. Its importance is evidenced by the fact that it is used as a backbone for TensorFlow, one of the most widely-used machine learning libraries. In this project, we will be implementing an Automatic Differentiation library that can be used as the basis for analysis methods, including a Newton’s Method extension that we will illustrate.


pkgId: 3abc5d3697ee3d9fcaefcfa0e67abaf38f1cfda06ffcd4d180b9bf9299f9ba2a
name: python-Clarify
arch: src
version: 0.6
epoch: 0
release: 1
summary: A Python package for parsing election results from Clarity systems
url: https://github.com/openelections/clarify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Clarify-0.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/openelections/clarify.svg?branch=master)](https://travis-ci.org/openelections/clarify)
  [![Code Coverage](https://codecov.io/gh/openelections/clarify/branch/master/graph/badge.svg)](https://codecov.io/gh/openelections/clarify)
  A Python library to discover and parse results for jurisdictions that use election results reporting systems from [SOE Software](http://www.soesoftware.com/product/clarity-election-night-reporting/), a Florida-based company that offers its products under the "Clarity" name. Web sites using Clarity are recognizable by URLs that begin with "http://results.enr.clarityelections.com" and have zip files containing structured data in XML, CSV and XLS format.
  Clarify offers an interface for discovering the locations of those zip files and another for parsing the XML versions of the data contained within them. Currently it does not handle downloading and unzipping those files, leaving that to the user.
  Clarify is tested using Python 2.7, 3.4, 3.5, and 3.6.


pkgId: 1944b09b7106b09c64fe6356ed2e6bad708ef84e07faaa0f7ab4d3105083e618
name: python-Clarity-SDK
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Python SDK for the Clarity API
url: https://test.pypi.org/legacy/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Clarity-SDK-1.0.9-1.src.rpm
checksum_type: sha256
description:
  To use any of our APIs you must create a developer account. A developer account provides an API Key for accessing our APIs, a playground for testing our APIs, and API usage metrics. Create or sign in using the buttons in the top right.
  ​
  After you create a new account, you will have a new API Key but it won't be linked to any of our APIs. To activate it for a particular API, navigate to [APIs](/apis) and find the API you want. Click `subscribe`. Your API Key is now subscribed to the API and you can make calls to its methods.
  ​
  Depending on the API configuration, subscribing to one API may subscribe you to several APIs. These APIs may have related functionality or share a pricing plan. Requests against any of them will be counted together in your usage.
  ​
  We know that figuring out how to use APIs can be hard. Use the “Try it out!” feature to get examples of the request and response shapes of our APIs. This makes an API call to the backend service using your API Key and provides a sample `curl` request with all necessary input parameters and the real response.
  ​
  Additional code examples and documentation can be found at the [Intuli](https://www.intuli.com) product page for your API subscriptions. You can also find the SDK documentation below.
  ​


pkgId: b84874a1bec7f5994cf3ee5199714746673292999aaaa1863e899164ed84af21
name: python-ClassHoster
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Host ANY Class
url: https://github.com/RepoFactory/ClassHoster
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ClassHoster-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Long READMEs are scary, so I'll keep this short. There is more info in the docs/README.md.
  This package is meant to take YOUR class, and make it very easy to use. Do this in one terminal.

      git clone https://github.com/Repo-Factory/ClassHoster && cd ClassHoster
      install.sh && ROBOT.py

  This will host the classes provided in ROBOT_SYSTEMS.

  In the second terminal

      test_class_hoster.py

  You'll see some output in the 2nd terminal that will help understand why this system is helpful.

  You can see generated stubs here for example class I provided.

      code ~/ROBOT_LIB/ROBOT_API.py


pkgId: ca57081d7593aafed3f100ece2a638471e2d0822172248fe164cb66adccd83b8
name: python-Classeviva.py
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Classeviva Python API wrapper
url: https://github.com/Lioydiano/Classeviva
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Classeviva.py-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [`Python`](https://python.org) [`API wrapper`](https://rapidapi.com/blog/api-glossary/api-wrapper/) per [`Classeviva`](https://web.spaggiari.eu/) (registro elettronico di [`GruppoSpaggiariParma`](https://web.spaggiari.eu/www/app/default/index.php))


  La [`documentazione italiana`](https://readthedocs.org/projects/classeviva/) si trova su [`ReadTheDocs.io`](https://readthedocs.org)


  Il codice sorgente può essere modificato su [`GitHub Dev`](https://github.dev) con l'[`editor della repository`](https://github.dev/Lioydiano/Classeviva)


  Il pacchetto può essere scaricato da [`PyPI`](https://pypi.org) tramite `pip`, il progetto si trova [`qui`](https://pypi.org/project/Classeviva.py/)


  L'`API REST` si trova a [`web.spaggiari.eu/rest`](https://web.spaggiari.eu/rest/), la documentazione si trova [su `GitHub`](https://github.com/Lioydiano/Classeviva-Official-Endpoints)


pkgId: 374ed8d2e2832c2034f23e6444efc42004aff2f8ffe13e82ee2c9626572165f1
name: python-Classeviva.py
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Classeviva Python API wrapper
url: https://github.com/Lioydiano/Classeviva
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Classeviva.py-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [`Python`](https://python.org) [`API wrapper`](https://rapidapi.com/blog/api-glossary/api-wrapper/) per [`Classeviva`](https://web.spaggiari.eu/) (registro elettronico di [`GruppoSpaggiariParma`](https://web.spaggiari.eu/www/app/default/index.php))


  La [`documentazione italiana`](https://readthedocs.org/projects/classeviva/) si trova su [`ReadTheDocs.io`](https://readthedocs.org)


  Il codice sorgente puÃ² essere modificato su [`GitHub Dev`](https://github.dev) con l'[`editor della repository`](https://github.dev/Lioydiano/Classeviva)


  Il pacchetto puÃ² essere scaricato da [`PyPI`](https://pypi.org) tramite `pip`, il progetto si trova [`qui`](https://pypi.org/project/Classeviva.py/)


  L'`API REST` si trova a [`web.spaggiari.eu/rest`](https://web.spaggiari.eu/rest/), la documentazione si trova [su `GitHub`](https://github.com/Lioydiano/Classeviva-Official-Endpoints)


pkgId: 4d983662a51ecef20b1af0c088d28072439ff76df0cad1d319cc25c58eb8ae2b
name: python-ClassicUPS
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Usable UPS Integration in Python
url: http://github.com/classicspecs/ClassicUPS/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ClassicUPS-0.1.8-1.src.rpm
checksum_type: sha256
description:
  ClassicUPS is an Apache2 Licensed wrapper around the UPS API for creating
  shipping labels and fetching a package's tracking status. This library by no
  means encompasses all of the UPS functionality, but it is suitable for some of
  the most common shipping-related common tasks.


pkgId: 698b271db453148422b3452ae3dd7235c929927eab017994df8fce9167362f07
name: python-Classy-AI
arch: src
version: 0.0.11
epoch: 0
release: 1
url: https://github.com/Mrpi314tech/Classy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Classy-AI-0.0.11-1.src.rpm
checksum_type: sha256
summary:
  A python module that utilizes AI to classify natural language into categories for processing with other models.

description:
  Install:
  <pre><code>pip install Classy-AI</code></pre>
  Setup: **Only do this if you plan to run the model locally**
  <pre><code>import Classy
  Classy.download()</code></pre>
  Downloads "data.pth" to your working directory. Also downloads the NLTK "punkt" tokenizer


  Usage (Complete version for a server):
  <pre><code>import Classy
  Classy.init('/path/to/data.pth','OpenAI api key')
  primary, secondary, stemmed, organized = Classy.server("hello, how are you?")</code></pre>
  Usage (Just the classifier)
  <pre><code>import Classy
  intent, certainty = Classy.classify("hello, how are you?",'/path/to/data.pth')</code></pre>



  Usage
  <pre><code>import Classy
  intent, certainty = Classy.classify_api("hello, how are you?")</code></pre>


  Go to http://chat.mrpi314.com/api to learn about how to use the api yourself.



  GPT:<pre><code>Classy.chat_gpt(input,model,api_key)</code></pre>
  DALL-E:<pre><code>Classy.dall_e(input,model,size,api_key)</code></pre>
  Search:<pre><code>Classy.search(input,model,api_key)</code></pre>
  Personal:<pre><code>Classy.personal(input)</code></pre>


  <pre><code>import Classy
  api_key='sk-proj-api-key'
  while True:
      var=input(': ')
      output,prob= Classy.classify_api(var)
      final=''
      secondary=''
      if output == 'GPT' and prob >= 0.7:
          final=Classy.chat_gpt(var,"gpt-4o-mini",api_key)
      elif output == 'Dall-e' and prob >= 0.7:
          final=Classy.dall_e(var,"dall-e-3","1024x1024",api_key)
      elif output == 'Search' and prob >= 0.7:
          final=Classy.search(var,"gpt-4o-mini",api_key)
      elif output == 'Personal' and prob >= 0.7:
          final,secondary,x,y=Classy.personal(var)
      print(final)
      if secondary:
          print(secondary)
  </code></pre>



  Open a pull request if you have some and put it in unorganized data. I will format it. If you have organized data, put it directly in the intents.json file.

  An easy way to contribute is by scrolling through your ChatGPT conversations/Google searches/DALL-E inputs and pasting some of your own data into the unformatted data file.

  http://chat.mrpi314.com

  Uses models gpt-4o-mini and dall-e-3.

  I can add a custom password for you on the website if you add training data. Message me at 123scoring@gmail.com. Put in the description of the pull request that you want a custom password for your Openai key.



  Thanks to [Patrick Loeber](https://github.com/patrickloeber) for teaching me PyTorch


