# packages

pkgId: eaaac5adf45086856287804bf2983250c89c4d7f33cc65f288d3ac33b5c3260c
name: python-causal-factory
arch: src
version: 0.1
epoch: 0
release: 1
summary: A placeholder for the causal-factory package
url: https://github.com/Awadelrahman/causal-factory
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causal-factory-0.1-1.src.rpm
checksum_type: sha256
description:
  This is a placeholder package to reserve the name causal-factory package. The full functionality will be added in future versions.


pkgId: 2d64051f5084a7db25c425d7b8290363dddea597c84cd642b102a247ba6775ea
name: python-causal-factory
arch: src
version: 0.2.2
epoch: 0
release: 1
url: https://github.com/Awadelrahman/causal-factory
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causal-factory-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  CausalFactory is Python package for causal model discovery and inference aims to seamlessly discover, visualize, and operationalize causal relationships

description:
  CausalFactory is Python package for causal model discovery and inference aims to seamlessly discover, visualize, and operationalize causal relationships


pkgId: 25f90ce1e8e31a7f87c5db4c24e9cd526b5e2227e31708b6cb4a3bf4d6da98e7
name: python-causal-learn
arch: src
version: 0.1.3.8
epoch: 0
release: 1
summary: causal-learn Python Package
url: https://github.com/py-why/causal-learn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causal-learn-0.1.3.8-1.src.rpm
checksum_type: sha256
description:
  Causal-learn is a python package for causal discovery that implements both classical and state-of-the-art causal discovery algorithms, which is a Python translation and extension of [Tetrad](https://github.com/cmu-phil/tetrad).

  The package is actively being developed. Feedbacks (issues, suggestions, etc.) are highly encouraged.



  Our causal-learn implements methods for causal discovery:

  * Constraint-based causal discovery methods.
  * Score-based causal discovery methods.
  * Causal discovery methods based on constrained functional causal models.
  * Hidden causal representation learning.
  * Permutation-based causal discovery methods.
  * Granger causality.
  * Multiple utilities for building your own method, such as independence tests, score functions, graph operations, and evaluations.



  Causal-learn needs the following packages to be installed beforehand:

  * python 3 (>=3.7)
  * numpy
  * networkx
  * pandas
  * scipy
  * scikit-learn
  * statsmodels
  * pydot

  (For visualization)

  * matplotlib
  * graphviz

  To use causal-learn, we could install it using [pip](https://pypi.org/project/causal-learn/):

  ```
  pip install causal-learn
  ```




  Please kindly refer to [causal-learn Doc](https://causal-learn.readthedocs.io/en/latest/) for detailed tutorials and usages.



  For search methods in causal discovery, there are various running examples in the **‘tests’** directory, such as TestPC.py and TestGES.py.

  For the implemented modules, such as (conditional) independent test methods, we provide unit tests for the convenience of developing your own methods.



  For the convenience of our community, [CMU-CLeaR](https://www.cmu.edu/dietrich/causality) group maintains a list of benchmark datasets including real-world scenarios and various learning tasks. Please refer to the following links:

  * [https://github.com/cmu-phil/example-causal-datasets](https://github.com/cmu-phil/example-causal-datasets) (maintained by Joseph Ramsey)
  * [https://www.cmu.edu/dietrich/causality/projects/causal_learn_benchmarks](https://www.cmu.edu/dietrich/causality/projects/causal_learn_benchmarks)

  Please feel free to let us know if you have any recommendation regarding causal datasets with high-quality. We are grateful for any effort that benefits the development of causality community.




  Please feel free to open an issue if you find anything unexpected.
  And please create pull requests, perhaps after passing unittests in 'tests/', if you would like to contribute to causal-learn.
  We are always targeting to make our community better!



  Although causal-learn provides python implementations for some causal discovery algorithms, there are currently a lot more in the classical Java-based [Tetrad](https://github.com/cmu-phil/tetrad) program. For users who would like to incorporate arbitrary Java code in Tetrad as part of a Python workflow, we strongly recommend considering [py-tetrad](https://github.com/cmu-phil/py-tetrad). Here is a list of [reusable examples](https://github.com/cmu-phil/py-tetrad/tree/main/pytetrad) of how to painlessly benefit from the most comprehensive Tetrad Java codebase.



  Please cite as:

  ```
  @article{causallearn,
    title={Causal-learn: Causal Discovery in Python},
    author={Yujia Zheng and Biwei Huang and Wei Chen and Joseph Ramsey and Mingming Gong and Ruichu Cai and Shohei Shimizu and Peter Spirtes and Kun Zhang},
    journal={arXiv preprint arXiv:2307.16405},
    year={2023}
  }
  ```


pkgId: 08b30faed71fa862c7e8462258b456d63f1405e28191aa650d8a792095673cfe
name: python-causal-pipe
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: A Python package streamlining the causal discovery pipeline for easy use.
url: https://github.com/albertbuchard/causal-pipe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causal-pipe-0.9.2-1.src.rpm
checksum_type: sha256
description:
  - **Visualization Outputs:** Ensure that the output directory specified in the configuration exists or is created by CausalPipe. The toolkit will save visualizations like correlation graphs, skeletons, oriented graphs, and SEM results in the specified `output_path`.
  - **R Package Dependencies:** Since CausalPipe integrates with R's `lavaan` and `mice` packages, make sure that R is installed on your system and that these packages are accessible. The toolkit attempts to install missing R packages automatically, but you may need to configure R's library paths or permissions accordingly.
  - **Error Handling:** The toolkit includes error handling to catch and report issues during data preprocessing, model fitting, and causal effect estimation. Pay attention to console outputs for any warnings or error messages that may require your attention.
  - **Extensibility:** CausalPipe is designed to be modular. You can extend its functionalities by adding new methods for skeleton identification, edge orientation, or causal effect estimation by creating new dataclasses and integrating them into the pipeline.
  - **Performance Considerations:** Some methods, especially those involving multiple imputation or complex SEM models, can be computationally intensive. Ensure that your system has sufficient resources, and consider optimizing parameters like `num_bootstrap_samples` or `max_iter` based on your dataset's size and complexity.
  By following this guide and leveraging the provided examples, you can effectively utilize **CausalPipe** to perform sophisticated causal discovery and analysis on your datasets.


pkgId: 3f85a72a8543d3f8eb251eec4db80b6744468768c42c1d5ec49880f5ba4802c3
name: python-causaldata
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Example Data Sets for Causal Inference
url: https://pypi.org/project/causaldata/
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causaldata-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Example data sets for running code examples from causal inference textbooks. For now this includes data sets from The Effect by Huntington-Klein and Causal Inference: The Mixtape by Cunningham.


pkgId: a1a26e62d88530e48ddf3f93c0cdb3e229457f177ff32e61bf9e635faaa745e7
name: python-causalimpact
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Python Package for causal inference using Bayesian structural time-series models
url: https://github.com/jamalsenouci/causalimpact/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causalimpact-0.2.6-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/jamalsenouci/causalimpact/actions/workflows/main.yml/badge.svg)](https://github.com/jamalsenouci/causalimpact/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/jamalsenouci/causalimpact/branch/master/graph/badge.svg?token=EIPC36VQHS)](https://codecov.io/gh/jamalsenouci/causalimpact)
  ![monthly downloads](https://pepy.tech/badge/causalimpact/month)
  [![DeepSource](https://deepsource.io/gh/jamalsenouci/causalimpact.svg/?label=active+issues&show_trend=true&token=R5aIDSkIId_5THWTAPKccjcH)](https://deepsource.io/gh/jamalsenouci/causalimpact/?ref=repository-badge)



  This is a port of the R package CausalImpact, see: https://github.com/google/CausalImpact.

  This package implements an approach to estimating the causal effect of a designed intervention on a time series. For example, how many additional daily clicks were generated by an advertising campaign? Answering a question like this can be difficult when a randomized experiment is not available. The package aims to address this difficulty using a structural Bayesian time-series model to estimate how the response metric might have evolved after the intervention if the intervention had not occurred.

  As with all approaches to causal inference on non-experimental data, valid conclusions require strong assumptions. The CausalImpact package, in particular, assumes that the outcome time series can be explained in terms of a set of control time series that were themselves not affected by the intervention. Furthermore, the relation between treated series and control series is assumed to be stable during the post-intervention period. Understanding and checking these assumptions for any given application is critical for obtaining valid conclusions.



  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jamalsenouci/causalimpact/HEAD?labpath=GettingStarted.ipynb)



  install the latest release via pip

  ```bash
  pip install causalimpact
  ```



  [Documentation and examples](https://nbviewer.org/github/jamalsenouci/causalimpact/blob/master/GettingStarted.ipynb)



  - Manuscript: [Brodersen et al., Annals of Applied Statistics (2015)](http://research.google.com/pubs/pub41854.html)



  The issue tracker is at https://github.com/jamalsenouci/causalimpact/issues. Please report any bugs that you find. Or, even better, fork the repository on GitHub and create a pull request.


pkgId: 70240f2dd37928968fc5414313d84ec8359a4baa4d46289420ee4d6afb78f060
name: python-causalite
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/awrao/causalite
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causalite-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Python package for defining and interacting with causal models, with a particular emphasis on Structural Causal Models

description:
      A <-  U_A
      X <-  1.0A - 3.0A^3 + U_X
      Y <-  - 0.5X + 1.2X^3 + 1.4A + 3.0XA + U_Y
  Here, U_A, U_X and U_Y represent the exogenous noise for variables A, X and Y respectively. We can draw a
  sample from the SCM and store it in a pandas dataframe as follows:
  ```python
  >>> samples = model.draw_sample(size=50000)
  >>> samples.head()
  ```
  |    |        A |          X |             Y |
  |:---|---------:|-----------:|--------------:|
  |0 | 1.764052 | -13.080164 |  -2746.102137 |
  |1 | 0.400157 |  -0.403826 |      0.142060 |
  |2 | 0.978738 |  -2.362115 |    -22.336143 |
  |3 | 2.240893 | -32.590699 | -41737.620108 |
  |4 | 1.867558 | -16.807889 |  -5782.921438 |
  For more detail and demonstrations of functionality such as simulation of interventions and counterfactual computation, please see
  this [notebook](https://github.com/awrao/causalite/blob/main/examples/GettingStarted.ipynb).

  Further illustrations of usage will be added to [examples](https://github.com/awrao/causalite/tree/main/examples) in due course.

  Please read [this](https://github.com/awrao/causalite/blob/main/CONTRIBUTING.md) if you wish to help or contribute to **causalite** in any way whatsoever.

  This project is licensed according to the [Apache 2.0 software license](https://github.com/awrao/causalite/blob/main/LICENSE).


pkgId: 1fa5aa786a06ac543e726be2b7723c1180afbc9f0ff403baacaab6f8a16294a8
name: python-causality
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Tools for causal inference
url: http://github.com/akelleh/causality
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causality-0.0.10-1.src.rpm
checksum_type: sha256
description:
  This package contains tools for causal analysis using observational (rather than experimental) datasets.



  Assuming you have pip installed, just run
  ```
  pip install causality
  ```



  The simplest interface to this package is probably through the `CausalDataFrame` object in [`causality.analysis.CausalDataFrame`](https://github.com/akelleh/causality/blob/master/causality/analysis/dataframe.py#L8). This is just an extension of the `pandas.DataFrame` object, and so it inherits the same methods.

  The `CausalDataFrame` current supports two kinds of causal analysis. First, it has a `CausalDataFrame.zmean` method. This method lets you control for a set of variables, `z`, when you're trying to estimate the effect of a discrete variable `x` on a continuous variable, `y`. It supports both returning the `y` estimates at each `x` value, as well as providing bootstrap error bars. For more details, check out the readme [here](https://github.com/akelleh/causality/tree/master/causality/analysis).

  The second kind of analysis supported is plotting to show the effect of discrete or continuous `x` on continous `y` while controlling for `z`. You can do this with the `CausalDataFrame.zplot` method. For details, check out the readme [here](https://github.com/akelleh/causality/tree/master/causality/analysis).




  the [`causality.estimation`](https://github.com/akelleh/causality/tree/master/causality/estimation) module contains tools for estimating causal effects from observational and experimental data. Most tools are parametric, like `PropensityScoreMatching`, and can be found in `causality.estimation.parametric`. Other models are non-parametric, and rely on directly estimating densities and using the g-estimation approach.




  The `causality.inference` module will contain various algorithms for inferring causal DAGs.  Currently (2016/01/23), the only algorithm implemented is the IC\* algorithm from Pearl (2000).  It has decent test coverage, but feel free to write some more!  I've left some stubs in `tests/unit/test\_IC.py`.

  To run a graph search on a dataset, you can use the algorithms like (using IC\* as an example):

  ```python
  import numpy
  import pandas as pd

  from causality.inference.search import IC
  from causality.inference.independence_tests import RobustRegressionTest


  SIZE = 2000
  x1 = numpy.random.normal(size=SIZE)
  x2 = x1 + numpy.random.normal(size=SIZE)
  x3 = x1 + numpy.random.normal(size=SIZE)
  x4 = x2 + x3 + numpy.random.normal(size=SIZE)
  x5 = x4 + numpy.random.normal(size=SIZE)


  X = pd.DataFrame({'x1' : x1, 'x2' : x2, 'x3' : x3, 'x4' : x4, 'x5' : x5})




  variable_types = {'x1' : 'c', 'x2' : 'c', 'x3' : 'c', 'x4' : 'c', 'x5' : 'c'}


  ic_algorithm = IC(RobustRegressionTest)
  graph = ic_algorithm.search(X, variable_types)
  ```

  Now, we have the inferred graph stored in `graph`.  In this graph, each variable is a node (named from the DataFrame columns), and each edge represents statistical dependence between the nodes that can't be eliminated by conditioning on the variables specified for the search.  If an edge can be oriented with the data available, the arrowhead is indicated in `'arrows'`.  If the edge also satisfies the local criterion for genuine causation, then that directed edge will have `marked=True`.  If we print the edges from the result of our search, we can see which edges are oriented, and which satisfy the local criterion for genuine causation:
  ```python
  >>> graph.edges(data=True)
  [('x2', 'x1', {'arrows': [], 'marked': False}),
   ('x2', 'x4', {'arrows': ['x4'], 'marked': False}),
   ('x3', 'x1', {'arrows': [], 'marked': False}),
   ('x3', 'x4', {'arrows': ['x4'], 'marked': False}),
   ('x4', 'x5', {'arrows': ['x5'], 'marked': True})]
  ```

  We can see the edges from `'x2'` to `'x4'`, `'x3'` to `'x4'`, and `'x4'` to `'x5'` are all oriented toward the second of each pair.  Additionally, we see that the edge from `'x4'` to `'x5'` satisfies the local criterion for genuine causation.  This matches the structure given in figure `2.3(d)` in Pearl (2000).




  The `causality.nonparametric` module contains a tool for non-parametrically estimating a causal distribution from an observational data set. You can supply an "admissable set" of variables for controlling, and the measure either the causal effect distribution of an effect given the cause, or the expected value of the effect given the cause.

  I've recently added adjustment for direct causes, where you can estimate the causal effect of fixing a set of X variables on a set of Y variables by adjusting for the parents of X in your graph.  Using the dataset above, you can run this like
  ```python
  from causality.estimation.adjustments import AdjustForDirectCauses
  from networkx import DiGraph

  g = DiGraph()

  g.add_nodes_from(['x1','x2','x3','x4', 'x5'])
  g.add_edges_from([('x1','x2'),('x1','x3'),('x2','x4'),('x3','x4')])
  adjustment = AdjustForDirectCauses()
  ```

  Then, you can see the set of variables being adjusted for by
  ```python
  >>> print(adjustment.admissable_set(g, ['x2'], ['x3']))
  set(['x1'])
  ```
  If we hadn't adjusted for `'x1'` we would have incorrectly found that `'x2'` had a causal effect on `'x3'` due to the counfounding pathway `x2, x1, x3`.  Adjustment for `'x1'` removes this bias.

  You can see the causal effect of intervention, `P(x3|do(x2))` using the measured causal effect in `adjustment`,
  ```python
  >>> from causality.estimation.nonparametric import CausalEffect
  >>> admissable_set = adjustment.admissable_set(g,['x2'], ['x3'])
  >>> effect = CausalEffect(X, ['x2'], ['x3'], variable_types=variable_types, admissable_set=list(admissable_set))
  >>> x = pd.DataFrame({'x2' : [0.], 'x3' : [0.]})
  >>> effect.pdf(x)
  0.268915603296
  ```

  Which is close to the correct value of `0.282` for a gaussian with mean 0. and variance 2.  If you adjust the value of `'x2'`, you'll find that the probability of `'x3'` doesn't change.  This is untrue with just the conditional distribution, `P(x3|x2)`, since in this case, observation and intervention are not equivalent.



  This repository is in its early phases.  The run-time for the tests is long.  Many optimizations will be made in the near future, including
  * Implement fast mutual information calculation, O( N log N )
  * Speed up integrating out variables for controlling
  * Take a user-supplied graph, and find the set of admissable sets
  * Front-door criterion method for determining causal effects

  Pearl, Judea. _Causality_.  Cambridge University Press, (2000).


pkgId: 915a5175a867f0fadae93820be773862ae9d6db4545981cbd59c6661363b3d1f
name: python-causalnlp
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: CausalNLP: A Practical Toolkit for Causal Inference with Text
url: https://github.com/amaiya/causalnlp/tree/main/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causalnlp-0.8.0-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->



  > CausalNLP is a practical toolkit for causal inference with text as
  > treatment, outcome, or “controlled-for” variable.



  - Low-code [causal
    inference](https://amaiya.github.io/causalnlp/examples.html) in as
    little as two commands
  - Out-of-the-box support for using [**text** as a “controlled-for”
    variable](https://amaiya.github.io/causalnlp/examples.html#What-is-the-causal-impact-of-a-positive-review-on-product-views?)
    (e.g., confounder)
  - Built-in
    [Autocoder](https://amaiya.github.io/causalnlp/autocoder.html) that
    transforms raw text into useful variables for causal analyses (e.g.,
    topics, sentiment, emotion, etc.)
  - Sensitivity analysis to [assess robustness of causal
    estimates](https://amaiya.github.io/causalnlp/causalinference.html#CausalInferenceModel.evaluate_robustness)
  - Quick and simple [key driver
    analysis](https://amaiya.github.io/causalnlp/key_driver_analysis.html)
    to yield clues on potential drivers of an outcome based on predictive
    power, correlations, etc.
  - Can easily be applied to [“traditional” tabular datasets without
    text](https://amaiya.github.io/causalnlp/examples.html#What-is-the-causal-impact-of-having-a-PhD-on-making-over-$50K?)
    (i.e., datasets with only numerical and categorical variables)
  - Includes an experimental [PyTorch
    implementation](https://amaiya.github.io/causalnlp/core.causalbert.html)
    of [CausalBert](https://arxiv.org/abs/1905.12741) by Veitch, Sridar,
    and Blei (based on [reference
    implementation](https://github.com/rpryzant/causal-bert-pytorch) by R.
    Pryzant)



  1.  `pip install -U pip`
  2.  `pip install causalnlp`

  **NOTE**: On Python 3.6.x, if you get a
  `RuntimeError: Python version >= 3.7 required`, try ensuring NumPy is
  installed **before** CausalNLP (e.g., `pip install numpy==1.18.5`).



  To try out the
  [examples](https://amaiya.github.io/causalnlp/examples.html) yourself:

  <a href="https://colab.research.google.com/drive/1hu7j2QCWkVlFsKbuereWWRDOBy1anMbQ?usp=sharing"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>



  ``` python
  import pandas as pd
  ```

  ``` python
  df = pd.read_csv('sample_data/music_seed50.tsv', sep='\t', on_bad_lines='skip')
  ```

  The file `music_seed50.tsv` is a semi-simulated dataset from
  [here](https://github.com/rpryzant/causal-text). Columns of relevance
  include: - `Y_sim`: outcome, where 1 means product was clicked and 0
  means not. - `text`: raw text of review - `rating`: rating associated
  with review (1 through 5) - `T_true`: 0 means rating less than 3, 1
  means rating of 5, where `T_true` affects the outcome `Y_sim`. - `T_ac`:
  an approximation of true review sentiment (`T_true`) created with
  [Autocoder](https://amaiya.github.io/causalnlp/autocoder.html) from raw
  review text - `C_true`:confounding categorical variable (1=audio CD,
  0=other)

  We’ll pretend the true sentiment (i.e., review rating and `T_true`) is
  hidden and only use `T_ac` as the treatment variable.

  Using the `text_col` parameter, we include the raw review text as
  another “controlled-for” variable.

  ``` python
  from causalnlp import CausalInferenceModel
  from lightgbm import LGBMClassifier
  ```

  ``` python
  cm = CausalInferenceModel(df,
                           metalearner_type='t-learner', learner=LGBMClassifier(num_leaves=500),
                           treatment_col='T_ac', outcome_col='Y_sim', text_col='text',
                           include_cols=['C_true'])
  cm.fit()
  ```

      outcome column (categorical): Y_sim
      treatment column: T_ac
      numerical/categorical covariates: ['C_true']
      text covariate: text
      preprocess time:  1.1179866790771484  sec
      start fitting causal inference model
      time to fit causal inference model:  10.361494302749634  sec



  CausalNLP supports estimation of heterogeneous treatment effects (i.e.,
  how causal impacts vary across observations, which could be documents,
  emails, posts, individuals, or organizations).

  We will first calculate the overall average treatment effect (or ATE),
  which shows that a positive review increases the probability of a click
  by **13 percentage points** in this dataset.

  **Average Treatment Effect** (or **ATE**):

  ``` python
  print( cm.estimate_ate() )
  ```

      {'ate': 0.1309311542209525}

  **Conditional Average Treatment Effect** (or **CATE**): reviews that
  mention the word “toddler”:

  ``` python
  print( cm.estimate_ate(df['text'].str.contains('toddler')) )
  ```

      {'ate': 0.15559234254638685}

  **Individualized Treatment Effects** (or **ITE**):

  ``` python
  test_df = pd.DataFrame({'T_ac' : [1], 'C_true' : [1],
                          'text' : ['I never bought this album, but I love his music and will soon!']})
  effect = cm.predict(test_df)
  print(effect)
  ```

      [[0.80538201]]

  **Model Interpretability**:

  ``` python
  print( cm.interpret(plot=False)[1][:10] )
  ```

      v_music    0.079042
      v_cd       0.066838
      v_album    0.055168
      v_like     0.040784
      v_love     0.040635
      C_true     0.039949
      v_just     0.035671
      v_song     0.035362
      v_great    0.029918
      v_heard    0.028373
      dtype: float64

  Features with the `v_` prefix are word features. `C_true` is the
  categorical variable indicating whether or not the product is a CD.



  Despite the “NLP” in CausalNLP, the library can be used for causal
  inference on data **without** text (e.g., only numerical and categorical
  variables). See [the
  examples](https://amaiya.github.io/causalnlp/examples.html#What-is-the-causal-impact-of-having-a-PhD-on-making-over-$50K?)
  for more info.



  API documentation and additional usage examples are available at:
  https://amaiya.github.io/causalnlp/



  Please cite [the following paper](https://arxiv.org/abs/2106.08043) when
  using CausalNLP in your work:

      @article{maiya2021causalnlp,
          title={CausalNLP: A Practical Toolkit for Causal Inference with Text},
          author={Arun S. Maiya},
          year={2021},
          eprint={2106.08043},
          archivePrefix={arXiv},
          primaryClass={cs.CL},
          journal={arXiv preprint arXiv:2106.08043},
      }


pkgId: 6aa1442e996bcbe558ff21a195da4f9f95a29121d561c9df866bb46363f2eee3
name: python-causing
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Causing: CAUSal INterpretation using Graphs
url: https://github.com/realrate/Causing
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causing-2.4.1-1.src.rpm
checksum_type: sha256
description:
  ✅ causal model given | ❌ causal search
  ✅ DAG directed acyclic graph | ❌ cyclic, undirected, or bidirected graph
  ✅ latent variables | ❌ just observed / manifest variables
  ✅ individual effects | ❌ just average effects
  ✅ direct, total, and mediation effects | ❌ just total effects
  ✅ structural model | ❌ reduced model
  ✅ small and big data | ❌ big data requirement
  ✅ graphical results | ❌ just numerical results
  ✅ XAI explainable AI | ❌ black box neural network
  The Causing approach is quite flexible. It can be applied to highly latent models with many of the modeled endogenous variables being unobserved. Exogenous variables are assumed to be observed and deterministic. The most severe restriction certainly is that you need to specify the causal model / causal ordering.

  Causing combines total effects and mediation effects in one single graph that is easy to explain.
  The total effects of a variable on the final variable are shown in the corresponding nodes of the graph. The total effects are split up over their outgoing edges, yielding the mediation effects shown on the edges. Just education has more than one outgoing edge to be interpreted in this way.
  The effects differ from individual to individual. To emphasize  this, we talk about individual effects. And the corresponding graph, combining total and mediation effects is called the Individual  Mediation Effects (IME) graph.

  Causing is free software written in _Python 3_. Graphs are generated using _Graphviz_. See dependencies in [setup.py](setup.py). Causing is available under MIT license. See [LICENSE](LICENSE.md "LICENSE").
  The software is developed by RealRate, an AI rating agency aiming to re-invent the rating market by using AI, interpretability, and avoiding any conflict of interest. See www.realrate.ai.
  When starting `python -m causing.examples example` after cloning / downloading the Causing repository you will find the results  in the _output_ folder. The results are saved in SVG files. The IME files show the individual mediation effects graphs for the respective individual.
  See `causing/examples` for the code generating some examples.

  To start your model, you have to provide the following information, as done in the example code below:
  - Define all your model variables as SymPy symbols.
  - Note that in Sympy some operators are special, e.g. Max() instead of max().
  - Provide the model equations in topological order, that is, in order of computation.
  - Then the model is specified with:
      - _xvars_: exogenous variables
      - _yvars_: endogenous variables in topological order
      - _equations_: previously defined equations
      - _final_var_: the final variable of interest used for mediation effects

  Assume a model defined by the equation system:
  Y<sub>1</sub> = X<sub>1</sub>
  Y<sub>2</sub> = X<sub>2</sub> + 2 * Y<sub>1</sub><sup>2</sup>
  Y<sub>3</sub> = Y<sub>1</sub> + Y<sub>2</sub>.
  This gives the following graphs. Some notes to understand them:
  - The data used consists of 200 observations. They are available for the x variables X<sub>1</sub> and X<sub>2</sub> with mean(X<sub>1</sub>) = 3 and mean(X<sub>2</sub>) = 2. Variables Y<sub>1</sub> and Y<sub>2</sub> are assumed to be latent / unobserved. Y<sub>3</sub> is assumed to be manifest / observed. Therefore, 200 observations are available for Y<sub>3</sub>.
  - To allow for benchmark comparisons, each individual effect is measured with respect to the mean of all observations.
  - Nodes and edges are colored, showing positive (_green_) and negative (_red_) effects they have on the final variable Y<sub>3</sub>.
  - Individual effects are based on the given model. For each individual, however, its _own_ exogenous data is put into the given graph function to yield the corresponding endogenous values. The effects are computed at this individual point. Individual effects are shown below just for individual no. 1 out of the 200 observations.
  - Total effects are shown below in the nodes and they are split up over the outgoing edges yielding the Mediation effects shown on the edges. Note, however, that just outgoing edges sum up to the node value, incoming edges do not. All effects are effects just on the final variable of interest, assumed here to be Y<sub>3</sub>.
  ![Individual Mediation Effects (IME)](https://github.com/realrate/Causing/raw/develop/images_readme/IME_1.svg)
  As you can see in the right-most graph for the individual mediation effects (IME), there is one green path starting at X<sub>1</sub> passing through Y<sub>1</sub>, Y<sub>2</sub>, and finally ending in Y<sub>3</sub>. This means that X<sub>1</sub> is the main cause for Y<sub>3</sub> taking on a value above average with its effect on Y<sub>3</sub> being +29.81. However, this positive effect is slightly reduced by X<sub>2</sub>. In total, accounting for all exogenous and endogenous effects, Y<sub>3</sub> is +27.07 above average. You can understand at one glance why Y<sub>3</sub> is above average for individual no. 1.
  You can find the full source code for this example [here](https://github.com/realrate/Causing/blob/develop/causing/examples/models.py#L16-L45).

  To dig a bit deeper, here we have a real-world example from social sciences. We analyze how the wage earned by young American workers is determined by their educational attainment, family characteristics, and test scores.
  This 5-minute introductory video gives a short overview of Causing and includes this real data example: See [Causing Introduction Video](https://youtu.be/GJLsjSZOk2w "Causing_Introduction_Video").
  See here for a detailed analysis of the Education and Wages example: [An Application of Causing: Education and Wages](docs/education.md).

  The Causing approach and its formulas together with an application are given in:
  > Bartel, Holger (2020), "Causal Analysis - With an Application to Insurance Ratings"
  DOI: 10.13140/RG.2.2.31524.83848
  https://www.researchgate.net/publication/339091133
  Note that in this early paper the mediation effects on the final variable of interest are called final effects. Also, while the current Causing version just uses numerically computed effects, that paper uses closed formulas.
  The paper proposes simple linear algebra formulas for the causal analysis of equation systems. The effect of one variable on another is the total derivative. It is extended to endogenous system variables. These total effects are identical to the effects used in graph theory and its do-calculus. Further, mediation effects are defined, decomposing the total effect of one variable on a final variable of interest over all its directly caused variables. This allows for an easy but in-depth causal and mediation analysis.
  The equation system provided by the user is represented as a structural neural network (SNN). The network's nodes are represented by the model variables and its edge weights are given by the effects. Unlike classical deep neural networks, we follow a sparse and 'small data' approach. This new methodology is applied to the financial strength ratings of insurance companies.
  > **Keywords:** total derivative, graphical effect, graph theory, do-Calculus, structural neural network, linear Simultaneous Equations Model (SEM), Structural Causal Model (SCM), insurance rating

  RealRate's AI software _Causing_ is a winner of the PyTorch AI Hackathon.
  <img src="https://github.com/realrate/Causing/raw/develop/images_readme/RealRate_AI_Software_Winner.png">
  We are excited to be a winner of the PyTorch AI Hackathon 2020 in the Responsible AI category. This is quite an honor given that more than 2,500 teams submitted their projects.
  [devpost.com/software/realrate-explainable-ai-for-company-ratings](https://devpost.com/software/realrate-explainable-ai-for-company-ratings "devpost.com/software/realrate-explainable-ai-for-company-ratings").

  Dr. Holger Bartel
  RealRate
  Cecilienstr. 14, D-12307 Berlin
  [holger.bartel@realrate.ai](mailto:holger.bartel@realrate.ai?subject=[Causing])
  Phone: +49 160 957 90 844
  [www.realrate.ai](https://www.realrate.ai "www.realrate.ai")


pkgId: 240665ade816d8981834173ae0ba9e7576fe4708e4f4965376566868a1bc6171
name: python-causy
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: Causal discovery made easy.
url: https://pypi.org/project/causy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-causy-0.1.24-1.src.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > causy is a prototype. Please report any issues and be mindful when using it in production.


  causy is a command line tool that allows you to apply causal inference methods like causal discovery and causal effect estimation. You can adjust causal discovery algorithms with easy to use, extend and maintain pipelines. causy is built based on pytorch which allows you to run the algorithms on CPUs as well as GPUs.

  causy workspaces allow you to manage your data sets, algorithm adjustments, and (hyper-)parameters for your experiments.

  causy UI allows you to look at your resulting graphs in the browser and gain further insights into every step of the algorithms.

  You can find the documentation [here](https://causy.dev/use/).


  Currently, we support python 3.11 and 3.12. To install causy run
  ```bash
  pip install causy
  ```


  Causy can be used with workspaces via CLI or via code.



  See options for causy workspace
  ```bash
  causy workspace --help
  ```

  Create a new workspace and start the process to configure your pipeline, data loader and experiments interactively. Your  input data should be a json file stored in the same directory.
  ```bash
  causy workspace init
  ```

  Add an experiment
  ```bash
  causy workspace experiment add your_experiment_name
  ```

  Update a variable in the experiment
  ```bash
  causy workspace experiment update-variable your_experiment_name your_variable_name your_variable_value
  ```

  Run multiple experiments
  ```bash
  causy workspace execute
  ```

  Compare the graphs of the experiments with different variable values via a matrix plot
  ```bash
  causy workspace diff
  ```

  Compare the graphs in the UI, switch between different experiments and visualize the causal discovery process
  ```bash
  causy ui
  ```



  Use a default algorithm

  ```python
  from causy.algorithms import PC
  from causy.graph_utils import retrieve_edges

  model = PC()
  model.create_graph_from_data(
      [
          {"a": 1, "b": 0.3},
          {"a": 0.5, "b": 0.2}
      ]
  )
  model.create_all_possible_edges()
  model.execute_pipeline_steps()
  edges = retrieve_edges(model.graph)

  for edge in edges:
      print(
          f"{edge[0].name} -> {edge[1].name}: {model.graph.edges[edge[0]][edge[1]]}"
      )

  ```


  Currently, causy supports the following algorithms:
  - PC (Peter-Clark)
    - PC - the original PC algorithm without any modifications ```causy.algorithms.PC```
    - ParallelPC - a parallelized version of the PC algorithm ```causy.algorithms.ParallelPC```


  Detailed information about the pipeline steps can be found in the [API Documentation](https://causy-dev.github.io/causy/causy.html).




  We recommend using poetry to manage the dependencies. To install poetry follow the instructions on https://python-poetry.org/docs/#installation.

  Install dependencies
  ```bash
  poetry install
  ```

  Execute tests
  ```bash
  poetry run python -m unittest
  ```
  Funded by the Prototype Fund from March 2024 until September 2024

  ![pf_funding_logos](https://github.com/causy-dev/causy/assets/94297994/4d8e4b18-dbe0-4549-bf7e-71f8bd24fdac)


pkgId: fc813dc352a241b6dcfb94be2196a47c5d00cc945f9e3f8bc32b5d03ebbd5c05
name: python-cavass
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: CAVASS python APIs.
url: https://pypi.org/project/cavass/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cavass-1.1.8-1.src.rpm
checksum_type: sha256
description:
  [toc]

  This library implements medical image processing methods involving using CAVASS software in Python environment.



  `pip install cavass`



  **ops.py** contains codes that implement CAVASS shell commands, like reading CAVASS format files, saving CAVASS format
  files, etc.

  **contrast_enhancement.py** contains windowing functions predefined in CAVASS GUI (soft tissue, bone, and PET).

  **converters.py** includes codes for converting medical image file formats, like converting images from NifTI format to
  CAVASS format.

  **registration.py** includes methods of matching images and segmentations for now.





  To use this package, Linux version of CAVASS is necessary to be
  installed, https://www.mipg.upenn.edu/Vnews/mipg_software.html. And the CAVASS package path is needed to add in the
  environment variables. If the CAVASS software is installed on the *"~/cavass-build"* path, you don't need to set the
  environment variable. Otherwise, you need to assign your CAVASS installation path before invoking any other methods in "
  cavass.ops".

  ```
  import cavass.ops

  cavass.ops.CAVASS_PROFILE_PATH = 'your CAVASS path'
  ```





  ```
  from cavass.ops import read_cavass_file

  input_file = 'N019PETCT.IM0'
  image = read_cavass_file(input_file, first_slice=None, last_slice=None)
  Output: np.ndarray[512, 512, 284]
  ```

  Typically, you only need to pass the "*input file*" to the function for reading the IM0 image or BIM segmentation. If
  you assign the first_slice/last_slice value(s), then only slices in this range would be returned.



  ```
  from cavass.ops import save_cavass_file

  data: np.ndarray uint16 for image, bool for segmentation

  save_cavass_file(output_file, data, binary=False, size=None, spacing=None, copy_pose_file=None)
  ```

  Save data to *output_file*. If data is an image, set *binary* to False. If data is a segmentation, set *binary* to True.
  Parameter *size* is the size of input data. The default is None, which means using the size of input data. You can
  directly ignore this parameter in most situations. Parameter *spacing* is used to set the voxel spacing of the input
  data. And if *copy_pose_file* exist, copy pose from reference file to the new output file. The most common scenario of
  using this function is to save a segmentation of a given medical image.

  ```
  from cavass.ops import save_cavass_file

  image_file = 'CT.IM0'
  output_file = 'CT_segmentation.BIM'
  segmentation: np.ndarray bool
  save_cavass_file(output_file, segmentation, binary=True, reference_file=image_file)
  ```

  Above code saves segmentation to output file CT_segmentation.BIM. And copy properties of image CT.IM0 to the new BIM
  file.



  ```
  from cavass.ops import copy_pose

  copy_pose(input_file1, input_file2, output_file)
  ```

  Copy properties (voxel spacing, orientation, etc.) of *<u>input_file2</u>* to *input_file1*, and output the new file
  *output_file*.



  ```
  from cavass.ops import export_math

  export_math(input_file, output_file, output_file_type='matlab', first_slice=-1, last_slice=-1)
  ```

  Export *input_file* to *output_file* with the format of *output_file_type*. The supported output formats include *
  *mathematica**, **mathlab**, **r**, and **vtk**. The parameters of  *first_slice* and the *last_slice* indicate the
  first and last slice index for export. If set to -1, the *first_slice* is set to 0, and the *last_slice* is set to the
  max slice index of the input image.





  ```
  from cavass.converters import dicom2cavass

  dicom2cavass(input_dir, output_file, offset_value=0)
  ```

  Convert dicom image to CAVASS format. *input_dir* is the directory that contains dicom files. CAVASS IM0 format uses
  uint16 as the data type. However, Hounsfield units have negative values. So *offset_value* is used to transfer HU to
  non-negative range, 1024 is commonly used for HU.



  ```
  from cavass.converters import nifti2cavass

  nifti2cavass(input_file, output_file, modality, offset_value=0, copy_pose_file)
  ```

  Convert input NIfTI image to CAVASS format. CAVASS IM0 format uses uint16 as the data type. However, Hounsfield units
  have negative values. So *offset_value* is used to transfer HU to the non-negative range, 1024 is commonly used for HU.
  Copy pose from the copy pose file to the output file if the copy pose file exists.



  ```
  from cavass.converters import nifti_label2cavass

  nifti_label2cavass(input_file, output_file, objects, modality, discard_background=True, copy_pose_file)
  ```

  Convert NIfTI format segmentation file to CAVASS BIM files. Since a NIfTI format segmentation file could contain
  arbitrary kinds of categories, and a CAVASS BIM file only contains one type of object, one NIfTI segmentation file may
  convert to multiple CAVASS BIM files. The final output file is {output_file}_{objects[i]}.BIM. *objects* can be an
  array, which contains the oject labels in the input NIfTI segmentation file that are desired to be converted, or a
  string split by commas. Copy pose from the copy pose file to the output file if the copy pose file exists.



  ```
  from cavass.converters import cavass2nifti

  cavass2nifti(input_file, output_file, orientation='ARI')
  ```

  Convert CAVASS format file to NIfTI format file. Parameter of *orientation* assigns the image orientation for the output
  NIfTI file. Supported options include ARI and LPI for now.



  ```
  from cavass.ops import get_image_resolution

  input_file = 'N019PETCT.IM0'
  r = get_image_resolution(input_file)
  Output: (512, 512, 284)
  ```



  ```
  from cavass.ops import get_voxel_spacing

  input_file = 'N019PETCT.IM0'
  r = get_voxel_spacing(input_file)
  Output: (0.976562, 0.976562, 3.0)
  ```



  ```
  from cavass.ops import bin_ops


  bin_ops(input_file_1, input_file_2, output_file, op)
  ```

  Perform binary operations between two input files *input_file_1* and *input_file_2*. The supported operations include *
  *or**, **nor**, **xor**, **xnor**, **and**, **nand**, and **a-b**.



  ```
  from cavass.ops import median2d

  median2d(input_file, output_file, mode=0)
  ```

  Perform 2D median filter to *input_file* and output *output_file*. Set *mode=0* for foreground filtering, *mode=1* for
  background.



  ```
  from cavass.ops import render_surface

  render_surface(input_bim_file, output_file)
  ```

  Render the surface of the input BIM file.

  Note that the rendering script may fail when saving output file in extension disks/partitions. I don't know the exact
  reason for this problem. But it seems related to the **track_all** script. Script "track_all {input_IM0_file}
  {output_file} 1.000000 115.000000 254.000000 26 0 0" can't save output file to disks/partitions except the system
  disk/partition.


  CAVASS `ndvoi input output mode [offx offy new_width new_height min max [min3 max3] [min4 max4] | [z]margin]`

  ```
  from cavass.ops import ndvoi

  ndvoi(untrimmed_file, output_file, min_slice_dim_3=inferior_slice_idx, max_slice_dim_3=superior_slice_idx)
  ```



  ```
  from cavass.ops import matched_reslice

  matched_reslice(file_to_reslice, file_to_match, output_file, interpolation_method=interpolation_method):
  ```



  ```
  from cavass.contrast_enhancement import cavass_soft_tissue_windowing,cavass_bone_windowing, cavass_pet_windowing

  input_image: np.ndarray

  output = cavass_soft_tissue_windowing(input_image)
  output: np.ndarray uint8

  output = cavass_bone_windowing(input_image)
  output: np.ndarray uint8

  output = cavass_pet_windowing(input_image)
  output: np.ndarray uint8
  ```

  The windowing methods are used to enhance the image contrast.

  cavass_soft_tissue_windowing uses a center of 1000, and a window width of 500.

  cavass_bone_windowing uses a center of 2000, and a window width of 4000.

  cavass_pet_windowing uses a center of 1200, a window width of 3500, and the invert transform.



  ```
  from cavass.match import match

  match(unmatched_file, file_to_match, output_file)
  ```



  ```
  from cavass.integration import integrate_trimmed_images



  integrate_trimmed_images(trimmed_files, reference_file, output_file_1, output_file_2)

  ```


pkgId: 774832c84f0448cf0ad1cb6ad7b16a23cadf7af0e9fa9dd958e21021f1a1f143
name: python-cavcalc
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A program for computing Fabry-Perot optical cavity parameters.
url: https://cavcalc.readthedocs.io/en/latest/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cavcalc-1.3.0-1.src.rpm
checksum_type: sha256
description:
  As well as providing a CLI, cavcalc has a full API which allows users to interact with this tool
  via Python. The recommended method for doing this is to use the single-function interface via
  [`cavcalc.calculate`](https://cavcalc.readthedocs.io/en/latest/api/generated/cavcalc.calculate.calculate.html#cavcalc.calculate.calculate). This
  function works similarly to the CLI, where a target can be specified along with a variable number of keyword
  arguments corresponding to the physical parameters. This function then returns one of two output objects (`SingleOutput`
  if a target was given, `MultiOutput` otherwise); see [`cavcalc.output`](https://cavcalc.readthedocs.io/en/latest/api/cavcalc.output.html#module-cavcalc.output)
  for details.
  For example, the following script will compute all available targets from the cavity length and mirror radii
  of curvature provided:
  ```python
  import cavcalc as cc

  out = cc.calculate(L="4km", Rc1=1934, Rc2=2245)


  print(out)
  ```
  producing:
  ```
  Given:
  	Cavity length = 4 km
  	Radius of curvature of first mirror = 1934 m
  	Radius of curvature of second mirror = 2245 m
  	Wavelength of beam = 1064 nm
  Computed:
  	FSR = 37474.05725 Hz
  	Mode separation frequency = 4988.072188176178 Hz
  	Position of beam waist (from first mirror) = 1837.2153886417168 m
  	Radius of beam at first mirror = 53.421066433049255 mm
  	Radius of beam at second mirror = 62.448079883230896 mm
  	Radius of beam at waist = 11.950538458990879 mm
  	Stability g-factor of cavity = 0.8350925761717987
  	Stability g-factor of first mirror = -1.0682523267838677
  	Stability g-factor of second mirror = -0.7817371937639199
  	Round-trip Gouy phase = 312.0813565565169 deg
  	Divergence angle = 0.0016237789746943276 deg
  ```
  An extra feature of the API is the ability to use the `cavcalc.configure` function for overriding
  default behaviour. For example, in the script below we use this in a context-managed scope to
  temporarily use microns for any beam radius parameters, mm for distances, and GHz for any frequencies:
  ```python
  import cavcalc as cc

  with cc.configure(beamsizes="um", distances="mm", frequencies="GHz"):
      out = cc.calculate(L=8, gouy=121)
      print(out)


  ```
  resulting in:
  ```
  Given:
      Cavity length = 8 mm
      Round-trip Gouy phase = 121 deg
      Wavelength of beam = 1064 nm
  Computed:
      FSR = 18.737028625 GHz
      Mode separation frequency = 6.297723510069445 GHz
      Position of beam waist (from first mirror) = 4.0 mm
      Radius of curvature of both mirrors = 0.01576117284251957 m
      Radius of beam at mirrors = 55.79464044247193 µm
      Radius of beam at waist = 48.19739141432035 µm
      Stability g-factor of cavity = 0.2424809625449729
      Stability g-factor of both mirrors = 0.4924235601034671
      Divergence angle = 0.40260921048107506 deg
  ```


pkgId: 7d855b550f4dcce71acb663193eef9576b9fe4b9648ff6902e505d77eb928722
name: python-caveclient
arch: src
version: 6.2.0
epoch: 0
release: 1
summary: A client for interacting with the Connectome Annotation Versioning Engine
url: https://github.com/CAVEconnectome/CAVEclient
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caveclient-6.2.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/CAVEclient)
  [![build status](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml/badge.svg)](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml) [![Downloads](https://static.pepy.tech/badge/caveclient)](https://pepy.tech/project/caveclient)

  CAVE is short for Connectome Annotation Versioning Engine. CAVE is a set of microservices
  that provide a framework for storing and versioning connectomics data and large sets of
  dynamic annotations, metadata, and segmentations. This repository supplies client-side
  code to easily interact with the microservices in CAVE.

  A full description of the Connectome Annotation Versioning Engine can be found [in this paper](https://www.biorxiv.org/content/10.1101/2023.07.26.550598v1).



  `CAVEclient` can be installed from PyPI:

  ```bash
  pip install caveclient
  ```

  Currently we are officially supporting and testing against python 3.8, 3.9, 3.10,  3.11 and 3.12.



  You can find full documentation at [caveconnectome.github.io/CAVEclient](https://caveconnectome.github.io/CAVEclient).


pkgId: c16f3fe8be5ee413c311aaeaef787a9f04b14fba6b05188de7c9eef6725ea03f
name: python-caveclient
arch: src
version: 7.0.4
epoch: 0
release: 1
summary: A client for interacting with the Connectome Annotation Versioning Engine
url: https://caveconnectome.github.io/CAVEclient/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caveclient-7.0.4-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/CAVEclient)
  [![build status](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml/badge.svg)](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml) [![Downloads](https://static.pepy.tech/badge/caveclient)](https://pepy.tech/project/caveclient)

  CAVE is short for Connectome Annotation Versioning Engine. CAVE is a set of microservices
  that provide a framework for storing and versioning connectomics data and large sets of
  dynamic annotations, metadata, and segmentations. This repository supplies client-side
  code to easily interact with the microservices in CAVE.

  A full description of the Connectome Annotation Versioning Engine can be found [in this paper](https://www.biorxiv.org/content/10.1101/2023.07.26.550598v1).



  `CAVEclient` can be installed from PyPI:

  ```bash
  pip install caveclient
  ```

  To add optional dependencies (currently for interfacing with the segmentation, imagery,
  and some skeleton formats via cloud-volume), you can install with the following:

  ```bash
  pip install caveclient[cv]
  ```



  Currently we are officially supporting and testing against Python 3.8, 3.9, 3.10, 3.11 and 3.12.



  You can find full documentation at [caveconnectome.github.io/CAVEclient](https://caveconnectome.github.io/CAVEclient).


pkgId: 75d8d7fd710d377fb3d4fcf2a38595bb81bcccfb4e16b53fa9316af5e9ed8cb0
name: python-cavityringdown
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: A package which analyzes cavity transmission ringdown to find the finesse of a cavity
url: https://github.com/kakitkelvinho/cavityringdown
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cavityringdown-0.0.8-1.src.rpm
checksum_type: sha256
description:
  ![test status](https://github.com/kakitkelvinho/cavityringdown/actions/workflows/python-app.yml/badge.svg?event=push)




  This is a package for analyzing the timetrace of a cavity ringdown experiment.



  Easiest way to use this is to install via pip:

  ```bash
  pip install cavityringdown
  ```

  For more details please visit the https://pypi.org/project/cavityringdown/ website.



  A graphical summary or a cheatsheet of this package is as follows:

  ```python










  experiment = Experiment('path/to/folder')



  ringdown = Ringdown(timetrace=timetrace, t=t)
  popt, pcov = ringdown.fit(plot=True)


  ringdowns = Ringdowns(name="name", ringdowns=[ringdown1, ringdown2,...])
  taus, tau_err = ringdowns.get_taus()
  ringdowns.plot_taus()
  ```



  This package makes no assumptions about how to run your experiments and how you store your data. What it requires is an array of time and array of the intensity. By passing on these two arrays, in other words the $x$ and $y$ of your experiment, it can fit to it and tell you the decay time constants of experiment.



  The structure of the directory is as follows:
  ```python
  analysis
  ├── loading.py
  ├── ringdown.py
  └── ringdowns.py
  ```

  To import the package to run in your script you can for example run:

  ```python
  from ringdown.analysis.ringdowns import Ringdowns
  from ringdown.analysis.ringdown import Ringdown
  ```

  Optionally, if your data structure permits (to be explained later):

  ```python
  from ringdown.analysis.loading import Experiment
  ```

  This offers a class to help you read into your experimental data and partition them into `Ringdown` and `Ringdowns`.





  The basic of classes are a `Ringdown` class, which is created by passing an array for time and an array for the timetrace.

  ```python
  ringdown = Ringdown(timetrace=timetrace, t=t)
  ```
  The numpy arrays `timetrace` and `t` could be obtained from your experimental data. For demonstration purposes, we can also generate a timetrace and 'load' it into an instance of the `Ringdown` class.
  ```python



  def generate_test_timetrace(a, tau, c, noise_sd, tEnd=2e-6, tInc=2.5e-10):
      '''Generates a timetrace of an exponential with a, tau, c
      and sprinkle in a normally distributed noise with a noise_sd.'''
      t = np.arange(0, tEnd, tInc)
      trace = a*np.exp(-t/tau) + c
      trace += np.random.normal(0, noise_sd, len(trace))

      return t, trace


  a, tau, c = [0.8, 1.2e-6, 0.]
  t, trace = self.generate_timetrace(a, tau, c, a/80)


  ringdown = Ringdown(timetrace=trace, t=t)
  ```



  Upon instantiating the `Ringdown` class, the class would automatically set a window or a region of interest in which a fit can be performed. This is performed by identifying the start time of the decay, in which case is identified by the time at which the intensity has the maximum value. The window is set to a default value of 1.5 $\mu$s, but this can be adjusted manually either by directly accessing the attribute or by passing `window` as a parameter to the `fit()` method.

  Once the class is instantiated, a fit can be performed. This is simply performed by the method `fit()`, which is called as follows:
  ```python
  ringdown = Ringdown(timetrace=timetrace, t=t)
  popt, pcov = ringdown.fit()
  ```
  We assume that the cavity ringdown is described by an exponential:
  $$ I(t) = I_0 \exp(-\frac{t}{\tau}) + C $$
  Programmatically, we denote $I_0$ by `a`, $\tau$ by `tau` and $C$ by `offset`. We also take the natural log of the decay to perform a (close to) linear fit using the `scipy.optimize.curve_fit` function. Thus, the fitting function, defined in the method `fit_func` is defined by `np.log(a*np.exp(-t/tau)+c)`, and calling the `fit` method performs a fit and returns the best fit parameters `popt` and the covariance matrix `pcov`. The order of the parameters are given as follows.
  ```python
  popt, pcov = ringdown.fit(plot=True)
  a, tau, c = popt
  sigma_a, sigma_tau, sigma_c = np.sqrt(np.diag(pcov))
  ```
  Passing `plot=True` as a parameter would also generate a graph with the following layout:
  ```python
          |---------------|
          |       |       |
          |       |   2.  |
          |       |       |
          |       |-------|
          |       |   3.  |
          |   1.  |-------|
          |       |       |
          |       |   4.  |
          |       |       |
          |       |-------|
          |       |   5.  |
          |---------------|
  ```
  In this figure:
  1. Corresponds to a plot of the full timetrace with lines showing the window / region of interest (ROI)
  2. Displays the log of the timetrace in the ROI and the fit over it
  3. Displays the residuals of 2.
  4. Displays the crop and normalized timetrace over the ROI and an intensity trace built by the best fit parameters, for visual inspection
  5. Displays the residuals of 4.




  As with most experiments, you never only do one measurements. You often repeatedly take many such ringdowns with the same experimental parameters. For example, for our ringdown measurements, we keep all parameters the same except for the angle of  polarizer situated right before our detector. Therefore, we would repeat a ringdown measurement 50 times for having a polarizer at an oritentation of $50^\circ$. It would be inconvenient to instantiate a ringdown for each of the 50 measurements, say by running:
  ```python

  ringdown1 = Ringdown(t=t0, timetrace=timetrace0)
  ringdown1 = Ringdown(t=t1, timetrace=timetrace1)
  ringdown2 = Ringdown(t=t2, timetrace=timetrace2)
  ringdown3 = Ringdown(t=t3, timetrace=timetrace3)
  ringdown4 = Ringdown(t=t4, timetrace=timetrace4)

  ```
  As such there is another class which allows you create a 'collection' of `Ringdown`. This class is known as `Ringdowns` and works like a python list, supporting in-place addition or appending with the `append` and `__add__` method. To instantiate `Ringdowns`, you pass in a name as an argument (which is also optional), and you can either incrementally add to its lists of `Ringdown` or instantiate it by passing the list to it already:

  ```python
  import numpy as np



  n = 50
  a = np.random.normal(0.7, 0.001, n)
  taus = np.random.normal(1.9e-6, 1e-8, n)
  c = 0.1


  ringdowns = Ringdowns(name='Polarizer 50deg')

  for i in range(n):
      
      t, trace = generate_test_timetrace(a[i], taus[i], c, noise_sd)
      
      ringdown = Ringdown(timetrace=trace, t=t)
      
      ringdowns += ringdown
  ```

  Upon instantiating a `Ringdowns` class, individual `Ringdown` can be accessed from this instance with list indexing. Each of the `Ringdown` can also have their methods be called.



  A reason why one would want to repeat measurements is to obtain an average and error for the fitted decay times over the many presumably identical measurements. This can be done by the following methods:
  - `get_taus()` returns a tuple `(taus, tau_errs)`, in which the first element `taus` is a list of the fitted decay time and the second element is a list of the errors associated from each of the fitted decay time obtained from the covariance matrix (see section 7.2 of Hughes and Hase).
  - `get_mean_taus()` and `get_std_taus()` calculates the sample mean and sample standard deviation of the decay times.
  - `plot_taus()` outputs a plot of the decay times with their error bars. Helpful for visualization and locating where the mean is.


pkgId: d4d4634713ed2c18aa0234ddf1e0457850f52d005b332166193414c6b2d5fa25
name: python-cavro
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: avro codec implemented with Cython
url: https://cavro.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cavro-1.0.0-1.src.rpm
checksum_type: sha256
description:
  An Avro serializer/deserializer for python written in cython.

  [Documentation](https://cavro.io/) and user guide here:

  https://cavro.io/


  Designed to be fast and usable.


pkgId: d07f18216d45ba51c462402099cb8c32ebf934e8c8248b38453a116900f400f9
name: python-caw
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: ChRIS client library
url: https://chrisproject.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caw-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/caw)](https://pypi.org/project/caw/)
  [![License - MIT](https://img.shields.io/pypi/l/caw)](https://github.com/FNNDSC/caw/blob/master/LICENSE)
  [![CI](https://github.com/FNNDSC/caw/actions/workflows/ci.yml/badge.svg)](https://github.com/FNNDSC/caw/actions)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  A Python _ChRIS_ client library.



  ```shell
  pip install -U caw
  ```



  ```python
  from pathlib import Path
  from chris.client import ChrisClient

  client = ChrisClient.from_login(
      address="https://cube.chrisproject.org/api/v1/",
      username="chris",
      password="chris1234"
  )
  client.upload(Path("example.txt"), "my_examples")
  dircopy = client.get_plugin_by_name("pl-dircopy")
  plinst = dircopy.create_instance({"dir": "chris/uploads/my_examples/example.txt"})
  ```



  Looking for an `async` _ChRIS_ client? Let us know!
  We have one implemented
  [here](https://github.com/FNNDSC/chrisomatic/tree/master/chris),
  though it's not published to PyPI.



  [chrs](https://github.com/FNNDSC/chrs/tree/master/chrs#readme)
  is the next-generation _ChRIS_ command-line client, please check it out.

  `caw` previously included a command-line client for _ChRIS_, however
  since v0.7.0 it was deprecated and removed.

  To use the `caw` command:

  ```shell
  pip install caw==0.6.1
  ```

  Usage: https://github.com/FNNDSC/caw/blob/d5b05b28af312b97ac80bd96376d70626db737a5/README.md


pkgId: ab2bbb039ecc3203ca1b8c3ec075134762b5c6c2372a3aa89ed61e5be4337fc5
name: python-cazy-webscraper
arch: src
version: 2.3.0.3
epoch: 0
release: 1
url: https://github.com/HobnobMancer/cazy_webscraper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cazy-webscraper-2.3.0.3-1.src.rpm
checksum_type: sha256
summary:
  A tool to automate retrieving data from CAZy, build a local CAZyme SQL database, and throughly interrogating the data. Also, automate retrieving protein data, sequences, EC numbers and structure files for specific datasets in the CAZyme database from UniProt, GenBank and PDB.

description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6343936.svg)](https://doi.org/10.5281/zenodo.6343936)
  [![licence](https://img.shields.io/badge/Licence-MIT-green)](https://github.com/HobnobMancer/cazy_webscraper/blob/master/LICENSE)
  [![CircleCI](https://circleci.com/gh/HobnobMancer/cazy_webscraper.svg?style=shield)](https://circleci.com/gh/HobnobMancer/cazy_webscraper)
  [![codecov](https://codecov.io/gh/HobnobMancer/cazy_webscraper/branch/master/graph/badge.svg)](https://codecov.io/gh/HobnobMancer/cazy_webscraper)
  [![Documentation Status](https://readthedocs.org/projects/cazy-webscraper/badge/?version=latest)](https://cazy-webscraper.readthedocs.io/en/latest/?badge=latest)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/cazy_webscraper/badges/version.svg)](https://anaconda.org/bioconda/cazy_webscraper)
  [![Anaconda-Update Badge](https://anaconda.org/bioconda/cazy_webscraper/badges/latest_release_date.svg)](https://anaconda.org/bioconda/cazy_webscraper)
  [![pyani PyPi version](https://img.shields.io/pypi/v/cazy_webscraper "PyPI version")](https://pypi.python.org/pypi/cazy_webscraper)
  [![Downloads](https://static.pepy.tech/badge/cazy-webscraper)](https://pepy.tech/project/cazy-webscraper)


pkgId: 2fc6f1fc7776dd777ddb4e34451a61b93bc781d9f8def3254ce55d344ece81bb
name: python-cbar-rates
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python library to work with AZN (Azerbaijani manat) official rates
url: https://pypi.org/project/cbar-rates/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbar-rates-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Python library to work with AZN (Azerbaijani manat) official rates based on [CBAR](https://cbar.az/currency/rates?language=en) (The Central Bank of the Republic of Azerbaijan)



  ```bash
  $ pip install cbar-rates --upgrade
  ```


  ```python
  from datetime import date
  import cbar

  rates_date = date.today()
  currencies = ["USD"]

  rates = cbar.get_rates(rates_date, currencies)

  print(rates)

  >>> {'date': '11.11.2024', 'currencies': {'USD': {'nominal': '1', 'value': 1.7}}}
  ```
  All available currency codes can be found on the [CBAR website](https://www.cbar.az/currency/rates?language=en)


pkgId: 94c2b8095a450be10fd0bb17dd8cc752c01e39098e191081823dcdccf2bdf094
name: python-cbar-rates
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python library to work with AZN (Azerbaijani manat) official rates
url: https://github.com/TahirJalilov/cbar-rates/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbar-rates-1.2.0-1.src.rpm
checksum_type: sha256
description:
  A Python library to work with Azerbaijani manat (AZN) official exchange rates based on [CBAR](https://cbar.az/currency/rates?language=en) (The Central Bank of the Republic of Azerbaijan).


  - Retrieve official CBAR exchange rates for the Azerbaijani manat (AZN).
  - Compare exchange rates between two dates and calculate differences.
  - Filter results by specific currency codes (e.g., USD, EUR).


  - Python 3.7 or higher
  - `requests` library



  Install the library using pip:

  ```bash
  pip install cbar-rates --upgrade
  ```

  For isolated installations, use a virtual environment:

  ```bash
  python3 -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  pip install cbar-rates
  ```




  ```python
  from datetime import date
  import cbar

  rates_date = date.today()
  currencies = ["USD", "EUR"]

  rates = cbar.get_rates(rates_date, currencies)

  print(rates)

  {
      "date": "18.11.2024",
      "currencies": {
          "USD": {
              "nominal": "1",
              "rate": 1.7
          },
          "EUR": {
              "nominal": "1",
              "rate": 1.7919
          },
      }
  }
  ```


  ```python
  from datetime import date
  import cbar

  previous_date = date(2024, 11, 25)
  date_ = date(2024, 11, 26)
  currencies = ["USD", "EUR"]

  rates = cbar.get_rates_with_diff(previous_date, date_, currencies)

  print(rates)

  {
      "previous_date": "25.11.2024",
      "date": "26.11.2024",
      "currencies": {
          "USD": {
              "nominal": "1",
              "previous_rate": 1.7,
              "rate": 1.7,
              "difference": 0.0,
          },
          "EUR": {
              "nominal": "1",
              "previous_rate": 1.7814,
              "rate": 1.7815,
              "difference": 0.0001,
          },
      }
  }
  ```

  You can find all available currency codes on the [CBAR website](https://www.cbar.az/currency/rates?language=en)


  This project is licensed under the [MIT License](https://github.com/TahirJalilov/cbar-rates?tab=MIT-1-ov-file#MIT-1-ov-file).


pkgId: cec387b1cfdad7d15b16b63781949e8d334aa29a0bdefe2c03bdc7af98b89750
name: python-cbaxter1988-utils
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: A Package containing my utils
url: https://github.com/cbaxter1988/utils.git
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbaxter1988-utils-0.9.4-1.src.rpm
checksum_type: sha256
description:
  These Packages are a collection of helpful utilities I utilize in numerous projects.





  ```text
  git clone https://github.com/cbaxter1988/utils.git
  pip install -r requirements.txt
  python invoke_tests.py
  ```



  Using PIP

  ```text
  pip install cbaxter1988-utils
  ```

  From Source

  ```text
  git clone https://github.com/cbaxter1988/utils.git
  python setup.py install
  ```





  Cloning Objects:

  ```python
  from cbaxter1988_utils import core_utils

  original_list = [1, 2, 3, 4]
  cloned_list = core_utils.clone_object(original_list)

  ```



  Utilities for interacting with your enviornment.

  Examples:

  ```python
  from cbaxter1988_utils import environment_utils


  try:
      var = environment_utils.get_env_strict(key="AWS_REGION")
  except KeyError:
      raise


  var = environment_utils.get_env(key="AWS_REGION", default_value="us-east-1")


  environment_utils.set_env(key="AWS_REGION", val="us-west-1")
  ```



  Utitilies for publishing and consuming messages with pika

  ```python
  from cbaxter1988_utils import pika_utils
  from cbaxter1988_utils.pika_utils import BlockingChannel
  from pika.spec import Basic, BasicProperties

  AMQP_USER = 'guest'
  AMQP_PW = 'guest'
  AMQP_HOST = '127.0.0.1'
  AMQP_PORT = 5672
  EXCHANGE_NAME = 'test_exchange'
  ROUTING_KEY_NAME = 'test_routing_key'
  QUEUE_NAME = 'QUEUE_NAME'
  AMQP_URL = pika_utils.make_amqp_url(amqp_user=AMQP_USER, amqp_pw=AMQP_PW, amqp_host=AMQP_HOST, amqp_port=AMQP_PORT)

  publisher = pika_utils.make_basic_pika_publisher(
      amqp_url=AMQP_URL,
      queue=QUEUE_NAME,
      exchange=EXCHANGE_NAME,
      routing_key=ROUTING_KEY_NAME
  )


  def message_handler(ch: BlockingChannel, method: Basic.Deliver, properties: BasicProperties, body):
      pass
      


  subscriber = pika_utils.make_basic_pika_consumer(
      amqp_url=AMQP_URL,
      queue=QUEUE_NAME,
      on_message_callback=message_handler
  )

  publisher.publish_message(body={"test": "data"})
  subscriber.run()
  ```


pkgId: 433031d9c9c4e6146bc69ca4b7cd8e16d9e38d167616821aa989c9478059e8eb
name: python-cbbs
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: bbs Decryption
url: https://github.com/Rin-Wood/cbbs
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbbs-1.0.1-1.src.rpm
checksum_type: sha256
description:
  `cbbs` is a Python package for decrypting data, using a custom bbs decryption algorithm implemented in C.



  - Provides efficient bbs decryption functionality, based on C implementation.
  - Supports Python 3.6+



  Install the latest version of `cbbs` from PyPI:

  ```bash
  pip install cbbs
  ```


  Here's how to use `cbbs` for decryption:

  ```python
  import cbbs

  dec = cbbs.decrypt(data)


pkgId: 375fc34e11b31a160d023e0f972e85f1998f77a404d0cde30253f70410782c0a
name: python-cbcflow
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A package for enabling CBC analyses
url: https://git.ligo.org/cbc/projects/cbcflow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbcflow-0.5.1-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the CBC Workflow project ("`cbcflow`").
  This consists of two parts - a metadata schema which governs the structure of the json files in which data is stored,
  and a code base which provides tools to interact with those files.



  This should be the first point of reference for usage and API of cbcflow.
  If you would like something to be added to the documentation, please contact the developers.



  CBC meta-data for O4 will be stored in structured json files, as recommended by an investigatory committee [here](https://dcc.ligo.org/LIGO-T2100502).
  The second version (v2) is currently in use, and is planned for use for the duration of the first part of the fourth observing run (O4a).
  For more information on the schema, please see [the appropriate section of the documentation](https://cbc.docs.ligo.org/projects/cbcflow/schema-visualization.html).



  `cbcflow` is a set of tools provided for users to interact with the metadata libraries being used. This includes:
  - Tools for creating new default metadata files, validating them against the schema and viewing their contents.
  - Monitors which pull information on events from GraceDB, according to structured queries.
  - An infrastructure for parsing libraries of these events, and configuration of those libraries which structures the aforemenetioned queries.
  - Index files which can provide summary information about the contents of libraries.
  - Hooks for interacting with Asimov.



  Development of `cbcflow` is principally coordinated through a dedicated mattermost channel, which is open to all collaboration members, found [here](https://chat.ligo.org/ligo/channels/cbcflow-development).

  For help with the usage of `cbcflow`, there is also a dedicated help channel, open to all collaboration members, which may be found [here](https://chat.ligo.org/ligo/channels/cbcflow-help).



  Development calls take place every other Wednesday at 8 PST / 11 EST / 16 UTC, and will take place on the CBC channel of teamspeak. Any interested collaboration member is welcome to attend.


  * Gregory Ashton
  * Rhiannon Udall
  * Zach Yarbrough



  * Rhiannon Udall (PE)
  * Wynn Ho (EM)
  * Simone Mastrogiovanni (Cosmology)
  * Suvodip Mukherjee (cosmology)
  * Aditya Vijaykumar (TGR)
  * Ronaldas Macas (Detchar)
  * Siddharth Soni (Detchar)
  * Apratim Ganguly (Lensing)
  * Ka-Lok Lo (Lensing)
  * Ethan Payne (R&P)
  * Shio Sakon (All-sky)



  * Dimitri Estevez (All-sky)
  * Bruce Edelman (R&P)


pkgId: 481d260a4fdbdb5212b962420f10a5eca41d96b0814a4e28b799699da7dfeb8b
name: python-cbebirr
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: CBEBirr integration
url: https://pypi.org/project/cbebirr/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbebirr-0.0.19-1.src.rpm
checksum_type: sha256
description:
  ```python
  import cbebirr

  if __name__ == '__main__':
      cbebirr.push_ussd(
          thirdPartyID='THIRD_PARTY_ID',
          primaryPartyIdentifier='PHONE',
          receiverPartyIdentifier='CUSTOMER_ID',
          intiatorIdentifier='IDENTIFIER',
          securityCredential='SECURITY_CREDENTIAL',
          posDeviceID='POS_DEVICE_ID',
          shortCode='SHORT_CODE',
          amount='10',
          password='PASSWORD',
          timestamp='TIME_STAMP',
          resultURL='RETURN_URL', )

      

  ```


pkgId: 794bf428466dd82bd44eccf7657eed9a0ab5601897cc700c35c426ab0c874b11
name: python-cbers4asat
arch: src
version: 0.7.3
epoch: 0
release: 1
url: https://cbers4asat.readthedocs.io/pt_BR/latest
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbers4asat-0.7.3-1.src.rpm
checksum_type: sha256
summary:
  Biblioteca Python para realizar a busca e processamento de imagens dos satélites CBERS-04A e AMAZONIA-1

description:
  [![Latest Version](https://img.shields.io/pypi/v/cbers4asat?style=plastic)](https://pypi.python.org/pypi/cbers4asat/)
  [![Latest Version](https://img.shields.io/pypi/l/cbers4asat?style=plastic)](https://github.com/gabriel-russo/cbers4asat/blob/master/LICENSE)
  [![Latest Version](https://img.shields.io/pypi/pyversions/cbers4asat?style=plastic)](https://pypi.python.org/pypi/cbers4asat/)
  [![Latest Version](https://img.shields.io/pypi/dm/cbers4asat?style=plastic)](https://pypi.python.org/pypi/cbers4asat/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
  ![GitHub Workflow Status](https://github.com/gabriel-russo/cbers4asat/actions/workflows/build-cbers4asat.yml/badge.svg)
  ![GitHub Workflow Status](https://github.com/gabriel-russo/cbers4asat/actions/workflows/build-cbers4asat-cli.yml/badge.svg)
  ![GitHub Workflow Status](https://github.com/gabriel-russo/cbers4asat/actions/workflows/test-cbers4asat.yml/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/cbers4asat/badge/?version=latest)](https://cbers4asat.readthedocs.io/pt_BR/latest/?badge=latest)
  > [Read this README in english (old version of docs)](https://github.com/gabriel-russo/cbers4asat/blob/master/en-US_README.md)
  > 🇺🇸

  ```python
  from cbers4asat import Cbers4aAPI
  from datetime import date

  api = Cbers4aAPI('email@mail.com')

  path_row = (229, 124)


  produtos = api.query(location=path_row,
                       initial_date=date(2021, 6, 1),
                       end_date=date(2021, 7, 1),
                       cloud=100,
                       limit=10,
                       collections=['AMAZONIA1_WFI_L2_DN', 'CBERS4A_WPM_L4_DN'])

  print(produtos)
  ```

  ```python

  from cbers4asat.tools import rgbn_composite
  import rasterio as rio
  from rasterio.plot import show

  rgbn_composite(red='./CBERS4A_WPM22812420210704/CBERS_4A_WPM_20210704_228_124_L4_BAND3.tif',
                 green='./CBERS4A_WPM22812420210704/CBERS_4A_WPM_20210704_228_124_L4_BAND2.tif',
                 blue='./CBERS4A_WPM22812420210704/CBERS_4A_WPM_20210704_228_124_L4_BAND1.tif',
                 nir='./CBERS4A_WPM22812420210704/CBERS_4A_WPM_20210704_228_124_L4_BAND4.tif',
                 filename='CBERS4A_WPM22812420210704_TRUE_COLOR.tif',
                 outdir='./STACK')

  raster = rio.open("./STACK/CBERS4A_WPM22812420210704_TRUE_COLOR.tif")
  show(raster.read(), transform=raster.transform)
  ```

  ```
  pip install cbers4asat
  ```
  Instalação com a caixa de ferramentas
  ```
  pip install "cbers4asat[tools]"
  ```

  Você pode ler a documentação da biblioteca no link abaixo
  > https://cbers4asat.readthedocs.io/

  Esse projeto foi meu objeto de estudo do Trabalho de Conclusão de Curso (TCC) no curso de Bacharelado em Ciência da Computação, você
  pode visualizar o PDF neste Link:
  [Repositório Institucional da Universidade Federal de Rondônia](https://ri.unir.br/jspui/handle/123456789/4345)

  Convido qualquer pessoa a participar contribuindo com código, relatando bugs,
  escrevendo documentação, criando tutoriais e discutindo o futuro deste projeto.
  Para mais informações de como contribuir ao projeto,
  leia [ao manual de contribuição](https://github.com/gabriel-russo/cbers4asat/blob/master/CONTRIBUTING.md)

  Você pode acompanhar todo o progresso do desenvolvimento
  no [painel de projetos](https://github.com/gabriel-russo/cbers4asat/projects)

  Copyright (c) 2023 Gabriel Russo
  Copyright (c) 2020 Sandro Klippel
  O uso é fornecido sob a Licença do MIT. Veja
  em [LICENSE](https://github.com/gabriel-russo/cbers4asat/blob/master/LICENSE)
  para mais detalhes.

rpm_license:
  MIT License  Copyright (c) 2023 Gabriel Russo Copyright (c) 2020 Sandro Klippel  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: d4493219573c7bea3a9668b002ef5cbb3dd66c0849499ea57f6479cb6b3a4b35
name: python-cbig_network_correspondence
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A toolbox for exploring network correspondence across atlases
url: https://rubykong.github.io/cbig_network_correspondence
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbig_network_correspondence-0.3.1-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: [https://rubykong.github.io/cbig_network_correspondence](https://rubykong.github.io/cbig_network_correspondence)
  **Source Code**: [https://github.com/rubykong/cbig_network_correspondence](https://github.com/rubykong/cbig_network_correspondence)


pkgId: f7edc9bdc85ffb8523c7201207f5dbac5c6df3f32d120a72e85ceaaaece07e6c
name: python-cbinterface
arch: src
version: 3.0.1
epoch: 0
release: 1
url: https://github.com/ace-ecosystem/cbinterface2
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbinterface-3.0.1-1.src.rpm
checksum_type: sha256
summary:
  command line tool for interfacing with multiple carbonblack environments to perform analysis and live response functions

description:
  `cbinterface` is a command line tool and library for interfacing with one or more Carbon Black environments.

  As of now, `cbinterface` primarily supports Carbon Black Enterprise EDR and Carbon Black Response. However, a lot of functionality should also work with other CBC products, like Enterprise Standard. If you're using Enterprise Standard and something doesn't work, open an issue and I can likely swap out an underlying object and have it working quickly.





  ```bash
  pip install cbinterface
  ```



  ```
  pip install git+https://github.com/ace-ecosystem/cbinterface2
  ```



  [Look here](https://github.com/ace-ecosystem/cbinterface2/wiki/Configuration) for help setting up and configuring `cbinterface`	 to work with your Carbon Black enviroments and according to your preferences.




  Check out the [Wiki Page](https://github.com/ace-ecosystem/cbinterface2/wiki) for detailed documentation and help.

  That said, if you don't find what you need, have a question about anything, or encounter an issue, open an issue here on Github and I'll help or fix it. If there is interest, I'll create more documentation around any subject.


pkgId: 5d2ae7033e1cbe46c6826aee9a7b34f0aff8d7140dd9ae7802ce89fbf0cf38b4
name: python-cbl-tools
arch: src
version: 0.1.25
epoch: 0
release: 1
summary: A small example package
url: https://gitlab.com/code_based_learning/python/cbl_tools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbl-tools-0.1.25-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2022 Alexander Voß  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: 9dbc325c2856b7dd87795de69c407dada0563032009ff40e0f7aef4591d06801
name: python-cblind
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Color schemes for Python plots, from Paul Tol (2012)
url: https://github.com/volodia99/cblind
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cblind-2.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cblind)](https://pypi.org/project/cblind/)

  A colorblind-friendly python module that allows color choice for plotting multiple curves
  Works only with python $\geq$ 3.7
  8 colormaps are now available to map 2D fields
  Authors: Gaylor Wafflard-Fernandez, Clément Robert
  Author-email: gaylor.wafflard@univ-grenoble-alpes.fr



  Install with `pip`

  ```
  pip install cblind
  ```

  To import cblind:

  ```python
  import cblind as cb
  ```



  10 palette functions to plot curves are available for now in the Colorplots class, with the corresponding test plotting functions.



  ```python
  color, linestyle = cb.Coloplots().cblind(nb_of_plots)
  ```

  from 1 to 12 plots [DISTINCT COLORS]. For more than 12 plots, the linestyle is changed.

  ```python
  cb.test_cblind(nb_of_plots)
  ```

  ![cblind](https://github.com/Volodia99/cblind/raw/master/imgs/cblind.png)



  ```python
  color, linestyle = cb.Coloplots().contrast(nb_of_plots)
  ```

  for less than 4 contrast plots [DISTINCT COLORS]. For more than 12 plots, the linestyle is changed.

  ```python
  cb.test_contrast(nb_of_plots)
  ```

  ![contrast](https://github.com/Volodia99/cblind/raw/master/imgs/contrast.png)



  ```python
  color, linestyle = cb.Coloplots().huescale(nb_of_plots, *option)
  ```

  from 1 to 9 plots [SEQUENTIAL DATA]. With option "blue","bluegreen","green", "gold","brown","rose","purple" for less than 3 plots, otherwise ocherscale.

  ```python
  cb.test_huescale(nb_of_plots, *option)
  ```

  ![huescale](https://github.com/Volodia99/cblind/raw/master/imgs/huescale.png)



  ```python
  color, linestyle = cb.Coloplots().rbscale(nb_of_plots)
  ```

  from 3 to 11 plots [DIVERGING DATA].

  ```python
  cb.test_rbscale(nb_of_plots)
  ```

  ![rbscale](https://github.com/Volodia99/cblind/raw/master/imgs/rbscale.png)



  ```python
  color, linestyle = cb.Coloplots().rainbow(nb_of_plots)
  ```

  from 4 to 12 plots [RAINBOW SCHEME].

  ```python
  cb.test_rainbow(nb_of_plots)
  ```

  ![rainbow](https://github.com/Volodia99/cblind/raw/master/imgs/rainbow.png)



  ```python
  color, linestyle = cb.Coloplots().extreme_rainbow(nb_of_plots)
  ```

  from 1 to 34 plots [RAINBOW SCHEME].

  ```python
  cb.test_extreme_rainbow(nb_of_plots)
  ```

  ![extreme_rainbow](https://github.com/Volodia99/cblind/raw/master/imgs/extreme_rainbow.png)



  ```python
  color, linestyle = cb.Coloplots().solstice(nb_of_plots)
  ```

  for less than 11 plots [DIVERGING DATA]

  ```python
  cb.test_solstice(nb_of_plots)
  ```

  ![solstice](https://github.com/Volodia99/cblind/raw/master/imgs/solstice.png)



  ```python
  color, linestyle = cb.Coloplots().bird(nb_of_plots)
  ```

  for less than 9 plots [DIVERGING DATA]

  ```python
  cb.test_bird(nb_of_plots)
  ```

  ![bird](https://github.com/Volodia99/cblind/raw/master/imgs/bird.png)



  ```python
  color, linestyle = cb.Coloplots().pregunta(nb_of_plots)
  ```

  for less than 9 plots [DIVERGING DATA]

  ```python
  cb.test_pregunta(nb_of_plots)
  ```

  ![pregunta](https://github.com/Volodia99/cblind/raw/master/imgs/pregunta.png)



  ```python
  color, linestyle = cb.Coloplots().monocolor(nb_of_plots, *option)
  ```

  from 1 to 13 monochromatic plots [MONOCOLOR/PRINTING] with different linestyles. With option "b&w", "blue", "red", "yellow", "green", "purple".

  ```python
  cb.test_monocolor(nb_of_plots, *option)
  ```

  ![monocolor](https://github.com/Volodia99/cblind/raw/master/imgs/monocolor.png)



  8 cblind palettes are available for now : "cb.rbscale", "cb.rainbow", "cb.extreme_rainbow", "cb.huescale",
  "cb.solstice", "cb.bird", "cb.pregunta", "cb.iris", but also all colormaps from matplotlib + "\_r" variants for reverse colormaps.

  ```python
  cmap = cb.cbmap(palette, nbin)
  ```

  The `nbin` argument is used to discretize the colormaps.

  ![colormaps](https://github.com/Volodia99/cblind/raw/master/imgs/colormaps.png)

  To test the colormaps, you can try:

  ```python
  cb.test_mapping(palette, nbin)
  ```



  ```python
  import numpy as np
  import matplotlib.pyplot as plt
  data2d = np.repeat(np.linspace(0,1,100),20).reshape(100,20).T

  fig, ax = plt.subplots()
  im = ax.imshow(data2d, cmap=cb.cbmap("cb.rainbow_r", nbin=10), aspect='auto')
  fig.colorbar(im)
  plt.show()
  ```



  ```python
  cb.mapping(fig,ax,data2d,extent,palette=palette,nbin=nbin)
  ```

  **REFERENCE**
  Paul Tol. 2012. "Colour Schemes." SRON Technical Note, SRON/EPS/TN/09-002.
  https://personal.sron.nl/~pault/data/colourschemes.pdf


pkgId: 6930aa17b71c19f7c71ecbddb585b058c5a9ae9bdacd1620f5fd089a5627c9cc
name: python-cbm
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: Checks by Monitoring (CbM)
url: https://github.com/ec-jrc/cbm
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbm-0.0.18-1.src.rpm
checksum_type: sha256
description:
  Copyright (c) 2022, [European Commission](https://ec.europa.eu/), Joint Research Centre. All rights reserved.


pkgId: fd32913fc3ff9b5d3b9ff6c463b05f2c619b83f1f2f00e73df7028115786e051
name: python-cbmc-starter-kit
arch: src
version: 2.10
epoch: 0
release: 1
summary: CBMC starter kit makes it easy to add CBMC verification to a software project
url: https://github.com/model-checking/cbmc-starter-kit
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbmc-starter-kit-2.10-1.src.rpm
checksum_type: sha256
description:
  This is a starter kit for writing CBMC proofs.

  [CBMC](https://github.com/diffblue/cbmc) is a model checker for
  C. This means that CBMC will explore all possible paths through your code
  on all possible inputs, and will check that all assertions in your code are
  true.
  CBMC can also check for the possibility of
  memory safety errors (like buffer overflow) and for instances of
  undefined behavior (like signed integer overflow).
  CBMC is a bounded model checker, however, which means that the set of all
  possible inputs may have to be restricted to all inputs of some bounded size.

  The [starter kit overview](https://model-checking.github.io/cbmc-training/starter-kit/overview/index.html)
  gives a fairly complete example of how to use the starter kit to add
  CBMC verification to an existing software project.

  The [starter kit wiki](https://github.com/awslabs/aws-templates-for-cbmc-proofs/wiki)
  is currently the primary user guide for the starter kit.



  The starter kit is distributed as both a brew package and a pip package, and the
  [release page](https://github.com/model-checking/cbmc-starter-kit/releases/latest)
  gives installation instructions that we repeat here.



  On MacOS, we recommend using brew to install the starter kit with
  ```
  brew tap aws/tap
  brew install cbmc-starter-kit
  ```
  and upgrade to the latest version with
  ```
  brew upgrade cbmc-starter-kit
  ```
  In these instructions, the first line taps an AWS repository that hosts the starter kit.
  The [brew home page](https://brew.sh/) gives instructions for installing brew.



  On any operating system with python installed, use pip to install the
  starter kit with
  ```
  python3 -m pip install cbmc-starter-kit
  ```
  and upgrade to the latest version with
  ```
  python3 -m pip install --upgrade cbmc-starter-kit
  ```
  The [python download page](https://www.python.org/downloads/) gives instructions
  for installing python.



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: c36f1929b2e28b548600cf7a55551fc0039991ed06da4ec22f772785eed0f4a0
name: python-cbmc-viewer
arch: src
version: 3.10
epoch: 0
release: 1
summary: CBMC viewer produces a browsable summary of CBMC findings
url: https://github.com/model-checking/cbmc-viewer
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbmc-viewer-3.10-1.src.rpm
checksum_type: sha256
description:
  [CBMC](https://github.com/diffblue/cbmc) is a Bounded Model Checker for C.
  It can prove that (for computations of bounded depth) a C program exhibits
  no memory safe errors (no buffer overflows, no invalid pointers, etc),
  no undefined behaviors, and no failures of assertions in the code.
  [CBMC Viewer](https://github.com/awslabs/aws-viewer-for-cbmc) is a tool
  that scans the output of CBMC and produces a browsable summary of its findings.



  Here is a simple example of using cbmc-viewer.
  Running this example requires installing [CBMC](https://github.com/diffblue/cbmc).
  Installation on MacOS is just `brew install cbmc`.
  Installation on other operation systems is described on the [CBMC
  release page](https://github.com/diffblue/cbmc/releases/latest).

  Create a source file `main.c` containing
  ```


  static int global;

  int main() {
    int *ptr = malloc(sizeof(int));

    assert(global > 0);
    assert(*ptr > 0);

    return 0;
  }
  ```
  and run the commands
  ```
  goto-cc -o main.goto main.c
  cbmc main.goto --trace --xml-ui > result.xml
  cbmc main.goto --cover location --xml-ui > coverage.xml
  cbmc main.goto --show-properties --xml-ui > property.xml
  cbmc-viewer --goto main.goto --result result.xml --coverage coverage.xml --property property.xml --srcdir .
  ```
  and open the report created by cbmc-viewer in a web browser with
  ```
  open report/html/index.html
  ```

  What you will see is

  * A *coverage report* summarizing what lines of source code were
    exercised by cbmc.  In this case, coverage is 100%.  Clicking on `main`,
    you can see the source code for `main` annotated with coverage data
    (all lines are green because all lines were hit).

  * A *bug report* summarizing what issues cbmc found with the code. In this case,
    the bugs are violations of the assertions because, for example, it is possible
    that the uninitialized integer allocated on the heap contains a negative value.
    For each bug, there is a link to

      * The line of code where the bug occurred.

      * An error trace showing the steps of the program leading to the bug.
        For each step, there a link to the line of code that generated the step,
        making it easy to follow the error trace and root cause the bug.



  The [cbmc-viewer documentation](https://model-checking.github.io/cbmc-viewer) includes a
  [reference manual](https://model-checking.github.io/cbmc-viewer/reference-manual) and a
  [user guide](https://model-checking.github.io/cbmc-viewer/user-guide).
  These documents are currently works in progress and will improve over time.



  Most people should just follow the instructions on the
  [release page](https://github.com/awslabs/aws-viewer-for-cbmc/releases/latest).

  Developers can install the package in Python "development mode" as follows.

  * Clone the repository and install dependencies with
    ```
        git clone https://github.com/awslabs/aws-viewer-for-cbmc.git cbmc-viewer
        apt install python3-pip python3-venv python3-jinja2 python3-voluptuous universal-ctags
    ```
    Installing ctags is optional. See the ctags discussion at the end of the
    [release page](https://github.com/awslabs/aws-viewer-for-cbmc/releases/latest).
  * Install development mode with
    ```
        cd cbmc-viewer
        make develop
        export PATH=/tmp/cbmc-viewer/bin:$PATH
    ```
  * Uninstall development mode with
    ```
        cd cbmc-viewer
        make undevelop
    ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 7a4871901d12e613a4de151b2868f86c9448824f3fafe09c7e41258d01e82aea
name: python-cbmi-utils
arch: src
version: 0.3.34
epoch: 0
release: 1
summary: Utility package for common features at CBMI
url: https://git.tools.f4.htw-berlin.de/baumapa/cbmi_utils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbmi-utils-0.3.34-1.src.rpm
checksum_type: sha256
description:
  Utility package for common features at CBMI. Further Information can be found in the [Wiki](https://gitlab.htw-berlin.de/baumapa/cbmi-utils/-/wikis/home).


  ```
  pip install cbmi-utils
  ```


  Example PyTorch Layer Import
  ```
  from cbmi_utils.pytorch.layers import Reshape
  ```


  - commit your changes on the dev branch and push to dev
  - increase version number in `setup.py` and commit with message `increase version number` and push to dev
  - merge to master and push
  - on the gitlab-page create new tag
    - Tag Name: `0.X.XX`
    - Message: `new version 0.X.XX`
    - Release Notes: `<your actual changes>`


pkgId: 4dfe02fc553dba95d8c3796379cc2bd8e50ab22a7611d7fb64780477a46f63a6
name: python-cbmpy
arch: src
version: 0.8.8.1
epoch: 0
release: 1
url: https://systemsbioinformatics.github.io/cbmpy/
rpm_license: GNU General Public License (GPL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbmpy-0.8.8.1-1.src.rpm
checksum_type: sha256
summary:
  CBMPy: https://systemsbioinformatics.github.io/cbmpy/ is a platform for constraint based modelling. It implements popular FBA analyses, model editing and supports the latest SBML3FBC standards.

description:
  CBMPy: https://systemsbioinformatics.github.io/cbmpy/ is a platform for constraint based modelling. It implements popular FBA analyses, model editing and supports the latest SBML3FBC standards.


pkgId: d7aa6bc8d9e70f8a0186389bee0bbf8d5063825cf022b841c49404f4cb01110f
name: python-cbor2
arch: src
version: 5.6.4
epoch: 0
release: 1
summary: CBOR (de)serializer with extensive tag support
url: https://pypi.org/project/cbor2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbor2-5.6.4-1.src.rpm
checksum_type: sha256
description:
  This library provides encoding and decoding for the Concise Binary Object Representation (CBOR)
  (`RFC 8949`_) serialization format. The specification is fully compatible with the original RFC 7049.
  `Read the docs <https://cbor2.readthedocs.io/>`_ to learn more.
  It is implemented in pure python with an optional C backend.
  On PyPy, cbor2 runs with almost identical performance to the C backend.


pkgId: 86deae15c87d8c750772b6b464b9fca2a2c63b9bc9f2e9fe25a3bd124eb371bd
name: python-cbpi4
arch: src
version: 4.4.6
epoch: 0
release: 1
summary: CraftBeerPi4 Brewing Software
url: http://web.craftbeerpi.com
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbpi4-4.4.6-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/PiBrewing/craftbeerpi4/actions/workflows/build.yml/badge.svg)](https://github.com/PiBrewing/craftbeerpi4/actions/workflows/build.yml)
  [![GitHub license](https://img.shields.io/github/license/PiBrewing/craftbeerpi4)](https://github.com/PiBrewing/craftbeerpi4/blob/master/LICENSE)
  ![GitHub issues](https://img.shields.io/github/issues-raw/PiBrewing/craftbeerpi4)
  ![PyPI](https://img.shields.io/pypi/v/cbpi4)
  ![Happy Brewing](https://img.shields.io/badge/CraftBeerPi%204-Happy%20Brewing-%23FBB117)

  <p align="center">
    <img src="https://github.com/PiBrewing/craftbeerpi4-ui/blob/main/cbpi4gui/public/logo192.png?raw=true" alt="CraftBeerPi Logo"/>
  </p>

  CraftBeerPi 4 is an open source software solution to control the brewing and
  fermentation of beer :beer:.


  Instructions on how to install CraftBeerPi and use its plugins is described
  in the documentation, that can be found here: [gitbook.io](https://openbrewing.gitbook.io/craftbeerpi4_support/).


  Plugins extend the base functionality of CraftBeerPi 4.
  You can find a list of available plugins [here](https://openbrewing.gitbook.io/craftbeerpi4_support/master/plugin-installation#plugin-list).


  You want to help develop CraftBeerPi4? To get you quickly stated, this repository comes with a preconfigured
  development environment. To be able to use this environment you need 2 things installed on your computer:

  - docker
  - visual studio code (vscode)

  To start developing clone this repository, open the folder in vscode and use the _development container_ feature. The command is called _Reopen in container_. Please note that this quick start setup does not work if you want to develop directly on a 32bit raspberry pi os because docker is only available for 64bit arm plattform. Please use the regular development setup for that.

  For a more detailed description of a development setup without the _development container_ feature see the documentation page:
  [gitbook.io](https://openbrewing.gitbook.io/craftbeerpi4_support/)


  Thanks to all the people who have contributed

  [![contributors](https://contributors-img.web.app/image?repo=PiBrewing/craftbeerpi4)](https://github.com/PiBrewing/craftbeerpi4/graphs/contributors)


pkgId: eea4b25941bdc7acee35e12454dde122da32df2af4dd05bba5bd66b5ebf69bce
name: python-cbr-website-beta
arch: src
version: 0.201.0
epoch: 0
release: 1
summary: CBR Website - Beta
url: https://github.com/the-cyber-boardroom/cbr-website-beta
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbr-website-beta-0.201.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graph/badge.svg?token=NZDJOJ2CYH)](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta)
  ![Current Release](https://img.shields.io/badge/release--blue)



  Main repo for The Cyber Boardroom website deployed in a serverless AWS environment (i.e. using Lambdas)




  Here is the [CodeCov page](https://app.codecov.io/gh/the-cyber-boardroom/cbr-website-beta) for this repo

  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/sunburst.svg?token=NZDJOJ2CYH)
  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/tree.svg?token=NZDJOJ2CYH)
  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/icicle.svg?token=NZDJOJ2CYH)


pkgId: f840d130868b46793be7120438045d0d4ec02f0aa8ad5d3cd532f9c65e2f5a08
name: python-cbra
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: A class-based REStful API framework built on FastAPI
url: https://docs.cochise.io/python/cbra/latest
rpm_license: Other/Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbra-1.1.10-1.src.rpm
checksum_type: sha256
description:
  - https://tyk.io/blog/your-data-model-is-not-an-api/
  - https://shekhargulati.com/2021/10/15/web-api-design-anti-pattern-exposing-your-database-model
  - https://cloud.google.com/blog/products/api-management/why-your-web-apis-should-be-entity-oriented
  - https://cloud.google.com/blog/products/application-development/api-design-why-you-should-use-links-not-keys-to-represent-relationships-in-apis
  - https://tools.ietf.org/html/rfc7807
  - https://www.iana.org/assignments/link-relations/link-relations.xhtml
  - https://thorben-janssen.com/dont-expose-entities-in-api/
  - https://vaadin.com/blog/ddd-part-3-domain-driven-design-and-the-hexagonal-architecture


pkgId: 3721c1c328d74f13f94e37a2af1ca766d7bb447474dc43f9e7accb4368c9f979
name: python-cbrext
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/kimbank/cbr-extractor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbrext-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  This tool extracts the Compressed Beamforming Report data from a PCAP file and saves it to a JSON file.

description:
  This tool extracts the Compressed Beamforming Report data from a PCAP file and saves it to a JSON or CSV file.



  ```plaintext
  python >= 3.9
  wireshark >= 4.4.0
  ```



  ```sh
  cbrext test/pcaps/beamforming.pcap -W test_out.json
  ```



  ```plaintext
  -h,  --help                     Show this help message and exit

  -d,  --dir                      Extract all PCAP files in a directory
  -W,  --write    <file or dir>   Write the extracted data to a file

  -sa, --src-addr <wlan.sa>       Filter by source address
  -su, --single-user              Extract SU
  -mu, --multi-user               Extract MU

  -j,  --json                     Write the extracted data to a JSON file (default)
  -c,  --csv                      Write the extracted data to a CSV file  # in progress
  -p,  --pcap                     Write the extracted data to a PCAP file # in progress
  -b,  --binary                   Decode the CBR hex to binary

  -i,  --info                     Print the CBR info
  -l,  --length                   Setting the length of the CBR data

  -v,  --verbose                  Print verbose output
  ```





  ```sh
  cbrext -d tests/pcaps/ -W test_out.json
  ```

  shell out:
  ```plaintext
  $ cbrext -d tests/pcaps/ -W test_out.json
  Processing tests/pcaps/ and generating output...
  [ 1/2 ] filtered_4F_0.pcap -> CBR Length: 7900612
  [ 2/2 ] filtered_4F_m0.pcap -> CBR Length: 12088706
  PCAP Count: 2
  Total CBR Length: 19989318
  ```

  json out:
  ```plaintext
  [
      [
          "75:2e:a9:68 ...",
          "75:2f:69:68 ...",
          ...
      ],
      [
          "69:70:77:f5 ...",
          "69:70:77:f5 ...",
          ...
      ]
  ]
  ```



  ```sh
  cbrext tests/pcaps/filtered_4F_0.pcap -W test_out.json -i -l 2639
  ```

  shell out:
  ```plaintext
  $ cbrext tests/pcaps/filtered_4F_0.pcap -W test_out.json -i -l 2639
  Processing tests/pcaps/filtered_4F_0.pcap and generating output...
  Total CBR Length: 7900612
  {'2639_2_3_2': {'nc': '2', 'nr': '3', 'min_antenna': '2', 'count': 126}, '2651_2_3_2': {'nc': '2', 'nr': '3', 'min_antenna': '2', 'count': 2153}}
  ```



  ```sh
  cbrext tests/pcaps/filtered_4F_0.pcap -W test_out.json -i -l 2639
  ```

  json out:

  __Note: It is recommended to determine and set an appropriate value to limit the length information of CBRs after analyzing it with the `-i` option. Currently, Wireshark has a bug where the CBR length is recognized as 4 bytes longer in portion of packets. Therefore, you can use the `-l` option to extract only the desired length and the `-i` option to check the number of antennas.__

  ```plaintext
  [
      "75:2e:a9:68 ...",
      "75:2f:69:68 ...",
      ...
  ]
  ```






  ```sh
  python -m pip install .
  ```



  ```sh
  python -m pip install --upgrade .
  ```



  ```sh
  python -m unittest discover -s tests
  ```



  ```sh
  python -m pip uninstall cbrext
  ```



  Meneghello, Francesca, Rossi, Michele, and Restuccia, Francesco. "DeepCSI: Rethinking Wi-Fi Radio Fingerprinting Through MU-MIMO CSI Feedback Deep Learning." In IEEE International Conference on Distributed Computing Systems, 2022.

  See: https://github.com/francescamen/DeepCSI for more details.


pkgId: bde73b956833f4ff1552d9365c7157449f575ec47cc8520ad94f9cc21a20f690
name: python-cbrf
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Wrapper for The Central Bank of the Russian Federation site API
url: https://github.com/egregors/cbrf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbrf-1.0.0-1.src.rpm
checksum_type: sha256
description:
  _Wrapper for The Central Bank of the Russian Federation site API_

  [![Build Status](https://github.com/egregors/cbrf/actions/workflows/python-package.yml/badge.svg)](https://github.com/egregors/cbrf/actions)
  [![PyPI version](https://badge.fury.io/py/cbrf.svg)](https://badge.fury.io/py/cbrf)

  [Site](https://www.cbr.ru/) and [API](https://www.cbr.ru/scripts/Root.asp?PrtId=SXML)
  of The Central Bank of the Russian Federation.



  Stable version:

  ```
      pip install cbrf
  ```

  Dev version:

  ```
      git clone https://github.com/Egregors/cbrf.git
      cd cbrf
      pip install -e .
  ```



  For using with your own hostname set environment variables, for example

  ```
  export CBRF_URL_SCHEME=https
  export CBRF_URL_HOST=www.my-own-cbr.ru
  ```





  To get raw XML answers you should use `cbrf.api` or `cbrf.asyncio.api` methods:

  ```
  >>> import cbrf
  >>> from cbrf.const import CurrencyCodes

  >>> cbrf.get_currencies_info()
  <Element 'Valuta' at 0x10b91f688>

  >>> cbrf.get_daily_rates()
  <Element 'ValCurs' at 0x10b82b9a8>

  >>> date_1 = datetime(2001, 3, 2)
  >>> date_2 = datetime(2001, 3, 14)
  >>> get_dynamic_rates(date_req1=date_1, date_req2=date_2, currency_id=CurrencyCodes.USD)
  <Element 'ValCurs' at 0x1107017c8>

  >>> import asyncio

  >>> asyncio.run(cbrf.asyncio.get_currencies_info())
  <Element 'Valuta' at 0x102492ca0>

  >>> asyncio.run(cbrf.asyncio.get_daily_rates())
  <Element 'ValCurs' at 0x104c36c00>

  >>> asyncio.run(cbrf.asyncio.get_dynamic_rates(date_req1=date_1, date_req2=date_2, currency_id=CurrencyCodes.USD))
  <Element 'ValCurs' at 0x1026a4860>
  ```



  You can use base models for work with API (see examples in the tests).

  `CurrenciesInfo`

  ```
  >>> from cbrf.models import CurrenciesInfo

  >>> c_info = CurrenciesInfo()
  >>> c_info.get_by_id("R01305").name
  'Ирландский фунт'
  >>> c_info.get_by_id("R01305").eng_name
  'Irish Pound'

  >>> import asyncio
  >>> from cbrf.asyncio import CurrenciesInfo

  >>> c_info = asyncio.run(CurrenciesInfo().create())
  >>> c_info.get_by_id("R01305").name
  'Ирландский фунт'
  >>> c_info.get_by_id("R01305").eng_name
  'Irish Pound'
  ```

  `DailyCurrenciesRates`

  ```
  >>> from cbrf.models import DailyCurrenciesRates

  >>> daily = DailyCurrenciesRates()
  >>> daily.date
  datetime.datetime(2017, 3, 11, 0, 0)
  >>> daily.get_by_id('R01035').name
  'Фунт стерлингов Соединенного королевства'
  >>> daily.get_by_id('R01035').value
  Decimal('72.0143')

  >>> import asyncio
  >>> from cbrf.asyncio import DailyCurrenciesRates

  >>> daily = asyncio.run(DailyCurrenciesRates().create())
  >>> daily.date
  datetime.datetime(2017, 3, 11, 0, 0)
  >>> daily.get_by_id('R01035').name
  'Фунт стерлингов Соединенного королевства'
  >>> daily.get_by_id('R01035').value
  Decimal('72.0143')
  ```

  `DynamicCurrenciesRates`

  ```
  >>> from cbrf.models import DynamicCurrenciesRates

  >>> date_1 = datetime(2001, 3, 2)
  ... date_2 = datetime(2001, 3, 14)
  ... id_code = 'R01235'
  >>> dynamic_rates = DynamicCurrenciesRates(date_1, date_2, id_code)
  >>> dynamic_rates.get_by_date(datetime(2001, 3, 8)).value
  Decimal('28.6200')

  >>> import asyncio
  >>> from cbrf.asyncio import DynamicCurrenciesRates

  >>> date_1 = datetime(2001, 3, 2)
  ... date_2 = datetime(2001, 3, 14)
  ... id_code = 'R01235'
  >>> dynamic_rates = asyncio.run(DynamicCurrenciesRates(date_1, date_2, id_code).create())
  >>> dynamic_rates.get_by_date(datetime(2001, 3, 8)).value
  Decimal('28.6200')

  ```

  Also, you can show `DEBUG` info, by setting logger level to DEBUG in your code:
  ```python
  import logging

  logging.basicConfig(level=logging.DEBUG)
  ```



  To run lint & tests:

  ```shell
  make lint
  make tests
  ```

  > You should install `pytest` first



  Bug reports, bug fixes, and new features are always welcome.
  Please open issues, and submit pull requests for any new code.


pkgId: d18fc510505d596f5b00949366d0c1f1790c4ac52d19da8dc4c321873f0c634e
name: python-cbrlib
arch: src
version: 2.0.10
epoch: 0
release: 1
summary: Case Based Reasoning library for Python
url: https://pypi.org/project/cbrlib/
rpm_license: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbrlib-2.0.10-1.src.rpm
checksum_type: sha256
description:
  [![Tests cbrlib - main branch](https://github.com/cdein/cbrlib/actions/workflows/library-test-main.yml/badge.svg)](https://github.com/cdein/cbrlib/actions/workflows/library-test-main.yml)
  [![PyPi](https://img.shields.io/pypi/v/cbrlib)](https://pypi.org/project/cbrlib/)


  Case Based Reasoning library for Python

  This library provides the possibility to integrate with native python. Basic implemetation can use instances of Python classes to calculate similarity between those objects.

  You can find a sparse description of case base reasoning at the [english wikipedia page](https://en.wikipedia.org/wiki/Case-based_reasoning). Please also take a look at the [examples](https://github.com/cdein/cbrlib/tree/main/examples).

  ```python
  import dataclasses
  import functools
  from typing import Optional

  from cbrlib import (
      Evaluator,
      FunctionCalculationParameter,
      NumericEvaluationOptions,
      ReasoningRequest,
      WeightedPropertyEvaluatorMapping,
  )
  from cbrlib import casebase, evaluate


  @dataclasses.dataclass(slots=True, frozen=True)
  class DataObject:
      color: Optional[str] = None
      shape: Optional[str] = None
      size: Optional[int] = None


  color_lookup = {
      "red": {"red": 1, "orange": 0.8, "yellow": 0.4},
      "orange": {"orange": 1, "red": 0.8, "yellow": 0.8},
  }
  color_evaluator = functools.partial(evaluate.table_lookup, color_lookup)


  def create_size_evaluator() -> Evaluator:
      options = NumericEvaluationOptions(
          min_=0,
          max_=100,
          if_less=FunctionCalculationParameter(tolerance=1.0),
          if_more=FunctionCalculationParameter(tolerance=1.0),
      )
      return functools.partial(evaluate.numeric, options)


  def dataobject_evaluator() -> Evaluator:
      mappings = (
          WeightedPropertyEvaluatorMapping("color", color_evaluator, 2),
          WeightedPropertyEvaluatorMapping("size", create_size_evaluator(), 1),
          WeightedPropertyEvaluatorMapping("shape", evaluate.equality, 1),
      )
      return functools.partial(evaluate.case_average, mappings)


  def main() -> None:
      data = [
          DataObject(color="red", shape="triangle", size=20),
          DataObject(color="orange", shape="circle", size=70),
          DataObject(color="green", shape="square", size=50),
      ]
      print("-" * 80)
      print(
          casebase.infer(
              data,
              ReasoningRequest(
                  query=DataObject(color="red"),
              ),
              dataobject_evaluator(),
          )
      )
      print("-" * 80)
      print(
          casebase.infer(
              data,
              ReasoningRequest(
                  query=DataObject(size=50),
              ),
              dataobject_evaluator(),
          )
      )
  ```

  A big thanky you to [myCBR](http://www.mycbr-project.org/) for the example data.


pkgId: 603615dbc1801229821314fe7be51e9495b345a52be4b2ae50a98b6d656e47a6
name: python-cbsodata
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: Statistics Netherlands opendata API client for Python
url: https://pypi.org/project/cbsodata/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbsodata-1.3.5-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://badge.fury.io/py/cbsodata.svg)](https://badge.fury.io/py/cbsodata)
  [![tests](https://github.com/J535D165/cbsodata/workflows/tests/badge.svg)](https://github.com/J535D165/cbsodata/actions)

  Retrieve data from the [open data interface of Statistics
  Netherlands](http://www.cbs.nl/nl-NL/menu/cijfers/statline/open-data/default.htm)
  (Centraal Bureau voor de Statistiek) with *Python*. The data is
  identical in content to the tables which can be retrieved and downloaded
  from [StatLine](http://statline.cbs.nl/). CBS datasets are accessed via
  the [CBS open data
  portal](https://opendata.cbs.nl/statline/portal.html).

  The documentation of this package is found at this page and on
  [readthedocs.io](http://cbsodata.readthedocs.io/).

  R user? Use
  [cbsodataR](https://cran.r-project.org/web/packages/cbsodataR/index.html).



  From PyPi

  ``` sh
  pip install cbsodata
  ```



  Load the package with

  ``` python
  >>> import cbsodata
  ```



  Statistics Netherlands (CBS) has a large amount of public available data
  tables (more than 4000 at the moment of writing). Each table is
  identified by a unique identifier (`Identifier`).

  ``` python
  >>> tables = cbsodata.get_table_list()
  >>> print(tables[0])
  {'Catalog': 'CBS',
   'ColumnCount': 18,
   'DefaultPresentation': '_la=nl&_si=&_gu=&_ed=LandVanUiteindelijkeZeggenschapUCI&_td=Perioden&graphType=line',
   'DefaultSelection': "$filter=((LandVanUiteindelijkeZeggenschapUCI eq '11111') or (LandVanUiteindelijkeZeggenschapUCI eq '22222')) and (Bedrijfsgrootte eq '10000') and (substringof('JJ',Perioden))&$select=LandVanUiteindelijkeZeggenschapUCI, Bedrijfsgrootte, Perioden, FiscaalJaarloonPerBaan_15",
   'ExplanatoryText': '',
   'Frequency': 'Perjaar',
   'GraphTypes': 'Table,Bar,Line',
   'ID': 0,
   'Identifier': '82010NED',
   'Language': 'nl',
   'MetaDataModified': '2014-02-04T02:00:00',
   'Modified': '2014-02-04T02:00:00',
   'OutputStatus': 'Regulier',
   'Period': '2008 t/m 2011',
   'ReasonDelivery': 'Actualisering',
   'RecordCount': 32,
   'SearchPriority': '2',
   'ShortDescription': '\nDeze tabel bevat informatie over banen en lonen bij bedrijven in Nederland, uitgesplitst naar het land van uiteindelijke zeggenschap van die bedrijven. Hierbij wordt onderscheid gemaakt tussen bedrijven onder Nederlandse zeggenschap en bedrijven onder buitenlandse zeggenschap. In de tabel zijn alleen de bedrijven met werknemers in loondienst meegenomen. De cijfers hebben betrekking op het totale aantal banen bij deze bedrijven en de samenstelling van die banen naar kenmerken van de werknemers (baanstatus, geslacht, leeftijd, herkomst en hoogte van het loon). Ook het gemiddelde fiscale jaarloon per baan is in de tabel te vinden. \n\nGegevens beschikbaar vanaf: 2008 \n\nStatus van de cijfers: \nDe cijfers in deze tabel zijn definitief.\n\nWijzigingen per 4 februari 2014\nDe cijfers van 2011 zijn toegevoegd.\n\nWanneer komen er nieuwe cijfers?\nDe cijfers over 2012 verschijnen in de eerste helft van 2015.\n',
   'ShortTitle': 'Zeggenschap bedrijven; banen, grootte',
   'Source': 'CBS.',
   'Summary': 'Banen en lonen van werknemers bij bedrijven in Nederland\nnaar land van uiteindelijke zeggenschap en bedrijfsgrootte',
   'SummaryAndLinks': 'Banen en lonen van werknemers bij bedrijven in Nederland<br />naar land van uiteindelijke zeggenschap en bedrijfsgrootte<br /><a href="http://opendata.cbs.nl/ODataApi/OData/82010NED">http://opendata.cbs.nl/ODataApi/OData/82010NED</a><br /><a href="http://opendata.cbs.nl/ODataFeed/OData/82010NED">http://opendata.cbs.nl/ODataFeed/OData/82010NED</a>',
   'Title': 'Zeggenschap bedrijven in Nederland; banen en lonen, bedrijfsgrootte',
   'Updated': '2014-02-04T02:00:00'}
  ```



  Get information about a table with the `get_info` function.

  ``` python
  >>> info = cbsodata.get_info('82070ENG') # Returns a dict with info
  >>> info['Title']
  'Caribbean Netherlands; employed labour force characteristics 2012'
  >>> info['Modified']
  '2013-11-28T15:00:00'
  ```



  The function you are looking for!! The function `get_data` returns a
  list of dicts with the table data.

  ``` python
  >>> data = cbsodata.get_data('82070ENG')
  [{'CaribbeanNetherlands': 'Bonaire',
    'EmployedLabourForceInternatDef_1': 8837,
    'EmployedLabourForceNationalDef_2': 8559,
    'Gender': 'Total male and female',
    'ID': 0,
    'Periods': '2012',
    'PersonalCharacteristics': 'Total personal characteristics'},
   {'CaribbeanNetherlands': 'St. Eustatius',
    'EmployedLabourForceInternatDef_1': 2099,
    'EmployedLabourForceNationalDef_2': 1940,
    'Gender': 'Total male and female',
    'ID': 1,
    'Periods': '2012',
    'PersonalCharacteristics': 'Total personal characteristics'},
   {'CaribbeanNetherlands': 'Saba',
    'EmployedLabourForceInternatDef_1': 1045,
    'EmployedLabourForceNationalDef_2': 971,
    'Gender': 'Total male and female',
    'ID': 2,
    'Periods': '2012',
    'PersonalCharacteristics': 'Total personal characteristics'},
   
  ]
  ```

  The keyword argument `dir` can be used to download the data directly to
  your file system.

  ``` python
  >>> data = cbsodata.get_data('82070ENG', dir="dir_to_save_data")
  ```



  There are multiple ways to retrieve data from catalogs other than
  'opendata.cbs.nl'. The code below shows 3 different ways to retrieve
  data from the catalog 'dataderden.cbs.nl' (known from Iv3).

  On module level.

  ``` python
  cbsodata.options.catalog_url = 'dataderden.cbs.nl'

  cbsodata.get_table_list()

  cbsodata.get_data('47003NED')
  ```

  With context managers.

  ``` python
  with cbsodata.catalog('dataderden.cbs.nl'):
      
      cbsodata.get_table_list()
      
      cbsodata.get_data('47003NED')
  ```

  As a function argument.

  ``` python

  cbsodata.get_table_list(catalog_url='dataderden.cbs.nl')

  cbsodata.get_data('47003NED', catalog_url='dataderden.cbs.nl')
  ```



  The package works well with Pandas. Convert the result easily into a
  pandas DataFrame with the code below.

  ``` python
  >>> data = pandas.DataFrame(cbsodata.get_data('82070ENG'))
  >>> data.head()
  ```

  The list of tables can be turned into a pandas DataFrame as well.

  ``` python
  >>> tables = pandas.DataFrame(cbsodata.get_table_list())
  >>> tables.head()
  ```



  This library ships with a Command Line Interface (CLI).

  ``` bash
  > cbsodata -h
  usage: cbsodata [-h] [--version] [subcommand]

  CBS Open Data: Command Line Interface

  positional arguments:
    subcommand  the subcommand (one of 'data', 'info', 'list')

  optional arguments:
    -h, --help  show this help message and exit
    --version   show the package version
  ```

  Download data:

  ``` bash
  > cbsodata data 82010NED
  ```

  Retrieve table information:

  ``` bash
  > cbsodata info 82010NED
  ```

  Retrieve a list with all tables:

  ``` bash
  > cbsodata list
  ```



  Use the flag `-o` to load data to a file (JSON lines).

  ``` bash
  > cbsodata data 82010NED -o table_82010NED.jl
  ```


pkgId: 1fc347fc8bffbd2f7f24419d3b4ad626ebb76f7bab845f7203e0794df0f7fe0a
name: python-cbw-api-toolbox
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: CyberWatch Api Tools.
url: https://github.com/Cyberwatch/cyberwatch_api_toolbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cbw-api-toolbox-2.3.2-1.src.rpm
checksum_type: sha256
description:
  This module has been deprecated. Please consider using [cyberwatch_api](https://github.com/Cyberwatch/cyberwatch_api).

  Please contact Cyberwatch support if you need help to migrate your existing scripts to the new client.



  A simple interface for your Cyberwatch instance API composed of a python library
  and a command line program.

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

  - [Installation](#installation)
    - [Prerequisites](#prerequisites)
    - [Install the latest package](#install-the-latest-package)
    - [Install an older package version](#install-an-older-package-version)
    - [Test your installation](#test-your-installation)
  - [Configuration](#configuration)
  - [Usage](#usage)
  - [API Documentation](#api-documentation)
  - [Command line Documentation](#command-line-documentation)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->




  - [ ] [Python 3](https://www.python.org/)
  - [ ] Python [PIP](https://pypi.org/project/pip/)



  To install Cyberwatch API toolbox, simply use python 3 with:

  ```bash
  $ pip3 install cbw-api-toolbox
  ```



  Some scripts from version 1.X may not work in version 2.X of `cbw-api-toolbox`, to install an older version, simply do:

  ```bash
  pip3 install cbw-api-toolbox==1.1.2
  ```



  **Create a new file called `ping.py` and copy/paste this content**

  ```python

  import os
  from configparser import ConfigParser
  from cbw_api_toolbox.cbw_api import CBWApi

  CONF = ConfigParser()
  CONF.read(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..', 'api.conf'))
  CLIENT = CBWApi(CONF.get('cyberwatch', 'url'), CONF.get('cyberwatch', 'api_key'), CONF.get('cyberwatch', 'secret_key'))

  CLIENT.ping()
  ```

  **Configure an api.conf file with your credentials**

  See the [Configuration](#configuration) section

  **Test your script**

  ```bash
  $ python3 ping.py
  ```

  If everything is ok, the `OK` message will appear

  ```bash
  $ python3 ping.py
  INFO:root:OK
  ```

  Otherwise, the `FAILED` message will appear

  ```
  $ python3 ping.py
  ERROR:root:FAILED
  ```

  In this case, please check that there are no typing errors in your `API_KEY`, `SECRET_KEY` or `API_URL` and that your Cyberwatch instance is up.



  Create an `api.conf` file at the root of the project (see `example_api.conf`)

  - `api_key`: your Cyberwatch user api key
  - `secret_key`: your Cyberwatch user secret key
  - `url`: your Cyberwatch instance URL

  **Example**

  ```conf
  [cyberwatch]
  api_key = PyXpxrcJ7rQ...
  secret_key = +bUx37WnB0qt...
  url = https://myinstance.local
  ```

  To find your API credentials:
    1. Click on your profile page in your cyberwatch instance web page
    2. Click on the button 'see my api keys'



  **Launch a script example**

  1. Choose a script from the [examples directory](examples) and copy it to your computer
  2. Edit the script with your API credentials (See [Configuration](#configuration))
  3. Launch the script

  ```bash
  $ python3 your_example_script_file.py
  ```



  See the full API documentation [here](https://docs.cyberwatch.fr/api/#introduction)



  See the command line interface documentation [here](docs/cli.md)


pkgId: 96139a682d709838d7dab81561c471c0f49e5eeff22cfbab958a14e3431c23a0
name: python-cc-agency
arch: src
version: 9.3.0
epoch: 0
release: 1
url: https://www.curious-containers.cc/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc-agency-9.3.0-1.src.rpm
checksum_type: sha256
summary:
  CC-Agency is part of the Curious Containers project. It connects to a cluster of docker-engines for the distributed execution of reproducible data-driven experiments defined in the RED format.

description:
  CC-Agency is part of the Curious Containers project. It connects to a cluster of docker-engines for the distributed execution of reproducible data-driven experiments defined in the RED format.

  For more information please refer to the Curious Containers [documentation](https://www.curious-containers.cc/).



  The Curious Containers software is developed at [CBMI](https://cbmi.htw-berlin.de/) (HTW Berlin - University of Applied Sciences). The work is supported by the German Federal Ministry of Economic Affairs and Energy (ZIM project BeCRF, grant number KF3470401BZ4), the German Federal Ministry of Education and Research (project deep.TEACHING, grant number 01IS17056 and project deep.HEALTH, grant number 13FH770IX6) and HTW Berlin Booster.


pkgId: 639977db77e0c908ae0a7aa0547f4e53699ef759a33e3b330aacb3dd8df61f1e
name: python-cc-ampapi
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A Python wrapper for the AMP API by CubeCoders
url: https://pypi.org/project/cc-ampapi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc-ampapi-0.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.    Includes other software related under the MIT license: - docs/extensions/*, Copyright (c) 2015-present Rapptz. For licensing see ./LICENSE-dpy


pkgId: 89ec2d5341eb69069a7a53608f53d9d1fe81253cf0521b775d803da4a491b62c
name: python-cc-backend-lib
arch: src
version: 0.17.0
epoch: 0
release: 1
summary: A library with classes and types used througout the backend for Conflict Cartographer
url: https://www.github.com/prio-data/cc_backend_lib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc-backend-lib-0.17.0-1.src.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/prio-data/cc_backend_lib/actions/workflows/pypi.yml/badge.svg)

  This library contains several classes and data models that are useful when
  writing services that interact with other services in Conflict Cartographer. In
  particular, the modules `api_client` and `schema` respectively provide classes
  for retrieving and modelling data from APIs.



  Data retrieval is offered via the `cc_backend_lib.dal.Dal` class. This class is
  instantiated by passing several API clients:

  ```
  from cc_backend_lib.clients import predictions_client, scheduler_client, users_client, countries_client
  from cc_backend_lib import dal

  cc_dal = dal.Dal(
        predictions = predictions_client.PredictionsClient(...),
        scheduler = scheduler_client.SchedulerClient(...),
        users = users_client.UsersClient(...),
        countries = countries_client.CountriesClient(...),
     )
  ```

  The class has several methods that offer access to data and summaries. See
  `help(Dal)`.  The `.participation_summary` method caches results for past
  (shift < 0) time-periods for efficiency.



  A powerful caching decorator is provided that lets you decorate both sync and
  async functions for caching. For using different kinds of backends or for other
  kinds of customization (LRU, etc.), the caching decorator lets you pass a
  custom cache class. There are some provided cache classes, including one that
  uses Redis:

  ```
  from cc_backend_lib.cache import redis_cache, cache

  @cache.cache(redis_cache.RedisBackend, host = "...", expiry_time = 100)
  def my_slow_function(a,b,c):
     ...


  a = my_slow_function(1,2,3)


  b = my_slow_function(1,2,3)

  assert a == b
  ```


pkgId: ef5f5e9e9bdc58ee83a34cd4da32d7ae5c2dd6faae013405f38b43bf0e158b92
name: python-cc-faice
arch: src
version: 9.3.0
epoch: 0
release: 1
url: https://www.curious-containers.cc/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc-faice-9.3.0-1.src.rpm
checksum_type: sha256
summary:
  FAICE (Fair Collaboration and Experiments) is part of the Curious Containers project. It enables researchers to perform and distribute reproducible data-driven experiments defined in the RED format.

description:
  FAICE (Fair Collaboration and Experiments) is part of the Curious Containers project. It enables researchers to perform and distribute reproducible data-driven experiments defined in the RED format.

  For more information please refer to the Curious Containers [documentation](https://www.curious-containers.cc/).



  The Curious Containers software is developed at [CBMI](https://cbmi.htw-berlin.de/) (HTW Berlin - University of Applied Sciences). The work is supported by the German Federal Ministry of Economic Affairs and Energy (ZIM project BeCRF, grant number KF3470401BZ4), the German Federal Ministry of Education and Research (project deep.TEACHING, grant number 01IS17056 and project deep.HEALTH, grant number 13FH770IX6) and HTW Berlin Booster.


pkgId: f9ad79f6f88dbd2e8d38d31f66b35b2df563ab202104f8e12398ef9f26359b62
name: python-cc-net
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Tools to download and clean Common Crawl
url: https://github.com/facebookresearch/cc_net
rpm_license: CC-BY-NC-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc-net-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Tools to download and clean Common Crawl as introduced in our paper [CCNet](https://arxiv.org/abs/1911.00359).

  If you found these resources useful, please consider citing:

  ```
  @article{wenzek2019ccnet,
    title={Ccnet: Extracting high quality monolingual datasets from web crawl data},
    author={Wenzek, Guillaume and Lachaux, Marie-Anne and Conneau, Alexis and Chaudhary, Vishrav and Guzman, Francisco and Joulin, Armand and Grave, Edouard},
    journal={arXiv preprint arXiv:1911.00359},
    year={2019}
  }
  ```

  [![CircleCI](https://circleci.com/gh/facebookresearch/cc_net.svg?style=svg)](https://circleci.com/gh/facebookresearch/cc_net)




  We only tried this on Linux but installation should be possible on MacOS too.

  1. Create or simlink a `data` folder to where you want to download the corpus.

  2. Run `make install`. This will download some resources and install required packages.

  3. If you have a C++ 17 compiler you can also run
  `pip install .[getpy]`, it provides more memory efficient hashset.

  4. Install the following tools manually if `make install` failed:
  - `lmplz` and `build_binary` from [KenLM](https://github.com/kpu/kenlm)
  - `spm_train` and `spm_encode` from [Sentence Piece](https://github.com/google/sentencepiece)



  The `Makefile` is used to train Sentence Piece and LM on Wikipedia data.

  * `make help` shows help
  * `make lang=de lm` trains a Sentence Piece and a LM on German Wikipedia
  * `make all_lm` trains the same model than in the paper
  * `make lang=de dl_lm` downloads the LM trained for the paper
  * `make dl_all_lm` downloads all of them



  The full mining pipeline is divided in 3 steps:

  - `hashes` downloads one Common-Crawl snapshot, and compute hashes for each paragraph
  - `mine` removes duplicates, detects language, run the LM and split by lang/perplexity buckets
  - `regroup` regroup the files created by `mine` in chunks of 4Gb

  Each step needs the previous step to be over before starting.
  You can launch the full pipeline using `python -m cc_net`.

  * `python -m cc_net --help` shows help
  * `python -m cc_net --dump 2019-13` treats a specific snapshot
  * `python -m cc_net -l my -l gu`
  restricts to specific languages
  * `python -m cc_net --lm_dir my_lms/` uses custom LMs
  * `python -m cc_net --lang_threshold 0.3` set a specific field in `mine.Config`
  * `python -m cc_net --config test` runs on a tiny subset of a snapshot
  * `python -m cc_net --config config/my_config.json` uses configuration from the given config file



  Given the CPU required to run the full pipeline on such a big corpus we share a mapping from url to the information we computed.
  You can reconstruct the corpus used in the paper by using:

  ```sh
  python -m cc_net --conf reproduce --dump 2019-09
  ```



  [Unsupervised Cross-lingual Representation Learning at Scale (XLM-RoBERTa)](https://arxiv.org/pdf/1911.02116.pdf)
  paper was trained on data extracted by an internal version of cc_net.

  Due to the format being a little bit different please use the following command instead:

  ```sh
  python cc_net/tools/dl_cc_100.py --help
  python cc_net/tools/dl_cc_100.py --outdir data_cc100 --process 8
  ```

  If you use this version of the data please also consider citing:

  ```bibtex
  @article{conneau2019unsupervised,
    title={Unsupervised Cross-lingual Representation Learning at Scale},
    author={Conneau, Alexis and Khandelwal, Kartikay and Goyal, Naman and Chaudhary, Vishrav and Wenzek, Guillaume and Guzm{\'a}n, Francisco and Grave, Edouard and Ott, Myle and Zettlemoyer, Luke and Stoyanov, Veselin},
    journal={arXiv preprint arXiv:1911.02116},
    year={2019}
  }
  ```




  Given the computation cost of running the full pipeline we distributed the computation
  on a [Slurm](https://slurm.schedmd.com/) cluster using [submitit](https://github.com/facebookincubator/submitit).
  `submitit` will default to spawning processes on your machine if Slurm cluster is found.
  You should tweak `--task_parallelism` to something adapated to your machine.
  Defaults are 512 for mining and 20 for reproducing.

  To run the tasks in-process use `--execution debug`.




  Generated files are compressed JSON files. There is one JSON object per line.

  __List of fields__:

  - url: webpage URL (part of CC)
  - date_download: date of download (part of CC)
  - digest: sha1 digest of the webpage (part of CC)
  - length: number of chars
  - nlines: number of lines
  - source_domain: web domain of the webpage
  - title: page title (part of CC)
  - raw_content: webpage content after deduplication
  - original_nlines: number of lines before deduplication
  - original_length: number of chars before deduplication
  - language: language detected by FastText LID
  - language_score: language score
  - perplexity: perplexity of a LM trained on Wikipedia

  __Sample JSON object__:
  ```json
  {
    "url": "http://www.pikespeakhospice.org/members/1420",
    "date_download": "2019-02-15T18:40:25Z",
    "digest": "sha1:VQW3KXUOALO543IJGTK2JLVEAN2XXKHI",
    "length": 752,
    "nlines": 5,
    "source_domain": "www.pikespeakhospice.org",
    "title": "LeeRoy Aragon",
    "raw_content": "Date Honored: March 2017\nHe was a man of integrity, a hard worker, and a dedicated family man. He loved spending time with family camping, fishing, hunting, boating and just hanging out.\nHis Catholic faith was extremely important to him as he gave of his time and talents to the community. He had many friends through church and the Knights of Columbus. He was a meticulous handyman, and enjoyed building and fixing things and restoring antique furniture to perfection. He was a fan and supported his Colorado Rockies and Denver Broncos. Throughout the years he had devoted four-legged friends (his dogs and a horse named Sunny Boy).\nWe have many cherished memories of him that we will treasure until we are with him again.\n~ Family of LeeRoy F. Aragon",
    "original_nlines": 7,
    "original_length": 754,
    "language": "en",
    "language_score": 0.99,
    "perplexity": 255.11,
  }
  ```

  You can peak at those files using UNIX tools `zcat` and [`jq`](https://stedolan.github.io/jq/manual/), eg:
  `zcat data/mined/2019-09/en_head_0000.json.gz | head -1 | jq .`

  `jq` can do some complicated filtering.
  `jsonql.py` provides a Python API with multiprocess support to do more complicated operations like LM scoring of the document.



  By contributing to `cc_net`, you agree that your contributions will be licensed
  under the LICENSE file in the root directory of this source tree.


pkgId: 0a439e0f1264fb8ffcf6031179e35d5bd1edcd4c33cc7130b5054b2da1be33df
name: python-cc.scpi
arch: src
version: 2024.8.31
epoch: 0
release: 1
summary: Wrapper of SCPI language for controlling various lab instruments.
url: https://github.com/uncertainty-cc/SCPI-Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc.scpi-2024.8.31-1.src.rpm
checksum_type: sha256
description:
  [![API-Docs-status](https://img.shields.io/github/actions/workflow/status/uncertainty-cc/SCPI-Python/build-docs.yaml?branch=main&style=flat-square&label=Docs&logo=googledocs&logoColor=fff)](https://uncertainty.cc/SCPI-Python/cc/scpi.html)

  The Standard Commands for Programmable Instruments (SCPI) defines a standard for syntax and commands to use in controlling programmable test and measurement devices. This Python module provides a wrapper for controlling various lab instruments.



  ```bash
  pip install cc-scpi
  ```


pkgId: bc316c13f5e4f688bf2c45b883f2683a8ee2757f4da8ce5d4ce2a4cb17f8938d
name: python-cc.udp
arch: src
version: 2024.9.1.post1
epoch: 0
release: 1
summary: UDP helper function for robotics workload.
url: https://github.com/uncertainty-cc/UDP-Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc.udp-2024.9.1.post1-1.src.rpm
checksum_type: sha256
description:
  [![API-Docs-status](https://img.shields.io/github/actions/workflow/status/uncertainty-cc/UDP-Python/build-docs.yaml?branch=main&style=flat-square&label=Docs&logo=googledocs&logoColor=fff)](https://uncertainty.cc/UDP-Python/cc/udp.html)


pkgId: 97fe4cd13829fd2c0606e5087a959bf5f4c1e6cf644b9afe22a74027a437191c
name: python-cc1101
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Python Library & Command Line Tool to Transmit RF Signals via C1101 Transceivers
url: https://github.com/fphammerle/python-cc1101
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cc1101-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![CI Pipeline Status](https://github.com/fphammerle/python-cc1101/workflows/tests/badge.svg)](https://github.com/fphammerle/python-cc1101/actions)
  [![Coverage Status](https://coveralls.io/repos/github/fphammerle/python-cc1101/badge.svg?branch=master)](https://coveralls.io/github/fphammerle/python-cc1101?branch=master)
  [![Last Release](https://img.shields.io/pypi/v/cc1101.svg)](https://pypi.org/project/cc1101/#history)
  [![Compatible Python Versions](https://img.shields.io/pypi/pyversions/cc1101.svg)](https://pypi.org/project/cc1101/)
  [![DOI](https://zenodo.org/badge/292333844.svg)](https://zenodo.org/badge/latestdoi/292333844)

  Python Library & Command Line Tool to Transmit RF Signals via [CC1101 Transceivers](https://www.ti.com/product/CC1101)



  ```sh
  $ pip3 install --user --upgrade cc1101
  ```

  On Raspbian / Raspberry Pi OS, dependencies can optionally be installed via:
  ```sh
  $ sudo apt-get install --no-install-recommends python3-spidev
  ```



  Connect the following pins directly:

  |CC1101 |Raspberry Pi        |
  |-------|--------------------|
  |VDD    | 3.3V (Pin 1 or 17) |
  |SI     | MOSI (Pin 19)      |
  |SO     | MISO (Pin 21)      |
  |CSn    | CE0 (Pin 24)       |
  |SCLK   | SCLK (Pin 23)      |
  |GDO2\* | Any GPIO pin, commonly GPIO25 (Pin 22) \[[1](https://github.com/SpaceTeddy/CC1101/blob/0d0f011d3b808e36ad57fab596ed5e1db9516856/README.md#hardware-connection),[2](https://allgeek.de/2017/07/31/cc1101-spi-raspberry-adapter-fuer-homegear-homematicmax/),[3](https://securipi.co.uk/cc1101.pdf)\] |
  |GDO0\* | Any GPIO pin, GPIO24 (Pin 18) recommended |
  |GND    | Ground             |

  No resistors required.
  Connection of pins marked with \* is optional.
  GDO2 stays "high until power and crystal have stabilized" (see `CHIP_RDYn` in docs).
  GDO0 is used by `.asynchronous_transmission()` for data input.

  If some of these pins are already in use,
  select a different SPI bus or chip select:
  https://www.raspberrypi.org/documentation/hardware/raspberrypi/spi/README.md
  ([permalink](https://github.com/raspberrypi/documentation/blob/d41d69f8efa3667b1a8b01a669238b8bd113edc1/hardware/raspberrypi/spi/README.md#hardware))

  Raspberry Pi GPIO docs: https://www.raspberrypi.org/documentation/usage/gpio/





  See [examples](https://github.com/fphammerle/python-cc1101/blob/master/examples/).

  ```python
  import cc1101

  with cc1101.CC1101() as transceiver:
      transceiver.set_base_frequency_hertz(433.92e6)
      print(transceiver)
      transceiver.transmit(b"\x01\xff\x00 message")
  ```

  In case CC1101 is connected to a different SPI bus or chip select line
  than `/dev/spidev0.0`,
  use `CC1101(spi_bus=?, spi_chip_select=?)`.



  ```sh
  $ printf '\x01\x02\x03' | cc1101-transmit -f 433920000 -r 1000
  ```

  See `cc1101-transmit --help`.



  In case a `PermissionError` gets raised,
  check the permissions of `/dev/spidev*`.
  You'll probably need `sudo usermod -a -G spi $USER`,
  followed by a re-login.

  Consult CC1101's offical docs for an in-depth explanation of all options:
  https://www.ti.com/lit/ds/symlink/cc1101.pdf


pkgId: e6783680f74c375ba2d5e840d4d3c928ed2ad8350cbb10bef21810b5dbbd231a
name: python-cca-zoo
arch: src
version: 2.6.0
epoch: 0
release: 1
url: https://github.com/jameschapman19/cca_zoo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cca-zoo-2.6.0-1.src.rpm
checksum_type: sha256
summary:
  Canonical Correlation Analysis Zoo: A collection of Regularized, Deep Learning based, Kernel, and Probabilistic methods in a scikit-learn style framework

description:
  <div align="center">

  <img src="docs/logos/cca-zoo-logo.svg" alt="drawing" width="200"/>



  **Unlock the hidden relationships in multiview data.**

  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5748062.svg)](https://doi.org/10.5281/zenodo.4382739)
  [![codecov](https://codecov.io/gh/jameschapman19/cca_zoo/branch/main/graph/badge.svg?token=JHG9VUB0L8)](https://codecov.io/gh/jameschapman19/cca_zoo)
  ![Build Status](https://github.com/jameschapman19/cca_zoo/actions/workflows/changes.yml/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/cca-zoo/badge/?version=latest)](https://cca-zoo.readthedocs.io/en/latest/?badge=latest)
  [![version](https://img.shields.io/pypi/v/cca-zoo)](https://pypi.org/project/cca-zoo/)
  [![downloads](https://img.shields.io/pypi/dm/cca-zoo)](https://pypi.org/project/cca-zoo/)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.03823/status.svg)](https://doi.org/10.21105/joss.03823)


  </div>



  In today's data-driven world, revealing hidden relationships across multiview datasets is critical. **CCA-Zoo** is your go-to library, featuring a robust selection of linear, kernel, and deep canonical correlation analysis methods.

  Designed to be user-friendly, CCA-Zoo is inspired by the ease of use in `scikit-learn` and `mvlearn`. It provides a seamless programming experience with familiar `fit`, `transform`, and `fit_transform` methods.



  - [Quick Start](#-quick-start)
  - [Performance Highlights](#-performance-highlights)
  - [Detailed Documentation](#-detailed-documentation)
  - [How to Cite](#-how-to-cite)
  - [Contribute](#-contribute)
  - [Acknowledgments](#-acknowledgments)





  Whether you're a `pip` enthusiast or a `poetry` aficionado, installing CCA-Zoo is a breeze:

  ```bash
  pip install cca-zoo

  pip install cca-zoo[probabilistic, visualisation, deep]
  ```

  For Poetry users:

  ```bash
  poetry add cca-zoo

  poetry add cca-zoo[probabilistic, visualisation, deep]
  ```

  Note that `deep` requires `torch` and `lightning` which may be better installed separately following the [PyTorch installation guide](https://pytorch.org/get-started/locally/).

  `probabilistic` requires `numpyro` which may be better installed separately following the [NumPyro installation guide](https://num.pyro.ai/en/stable/getting_started.html#installation).

  `visualisation` requires `matplotlib` and `seaborn`



  CCA-Zoo is designed to be compatible with the machine learning ecosystem. It is built on top of `scikit-learn`, `tensorly`, `torch`, `pytorch-lightning`, and `numpyro`.

  <img src="docs/_static/CCA_Zoo_map.svg" alt="drawing" width="1000"/>


  CCA-Zoo shines when it comes to high-dimensional data analysis. It significantly outperforms scikit-learn, particularly as dimensionality increases. For comprehensive benchmarks, see our [script](benchmark/cca_high_dimensions.py) and the graph below.

  ![Benchmark Plot CCA](benchmark/CCA_Speed_Benchmark.svg)
  ![Benchmark Plot PLS](benchmark/PLS_Speed_Benchmark.svg)



  Embark on a journey through multiview correlations with our [comprehensive guide](https://cca-zoo.readthedocs.io/en/latest/).



  Your support means a lot to us! If CCA-Zoo has been beneficial for your research, there are two ways to show your appreciation:

  1. Star our GitHub repository.
  2. Cite our research paper in your publications.

  For citing our work, please use the following BibTeX entry:

  ```bibtex
  @software{Chapman_CCA-Zoo_2023,
  author = {Chapman, James and Wang, Hao-Ting and Wells, Lennie and Wiesner, Johannes},
  doi = {10.5281/zenodo.4382739},
  month = aug,
  title = {{CCA-Zoo}},
  url = {https://github.com/jameschapman19/cca_zoo},
  version = {2.3.0},
  year = {2023}
  }
  ```

  Or check out our JOSS paper:

  📜 Chapman et al., (2021). CCA-Zoo: A collection of Regularized, Deep Learning based, Kernel, and Probabilistic CCA methods in a scikit-learn style framework. Journal of Open Source Software, 6(68), 3823, [Link](https://doi.org/10.21105/joss.03823).



  Every idea, every line of code adds value. Check out our [contribution guide](https://cca-zoo.readthedocs.io/en/latest/developer_info/contribute.html) and help CCA-Zoo soar to new heights!



  Special thanks to the pioneers whose work has shaped this field. Explore their work:

  - Regularised CCA/PLS: [MATLAB](https://github.com/anaston/PLS_CCA_framework)
  - Sparse PLS: [MATLAB SPLS](https://github.com/jmmonteiro/spls)
  - DCCA/DCCAE: [Keras DCCA](https://github.com/VahidooX), [Torch DCCA](https://github.com/Michaelvll/DeepCCA)


pkgId: 9bd13767dda04d26f522928907711c39fb2bd7685769543a0f7a5b80f01a1476
name: python-ccaaws
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: AWS boto3 objects for python
url: https://pypi.org/project/ccaaws/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccaaws-0.4.8-1.src.rpm
checksum_type: sha256
description:
  Python objects wrapped around [boto3](https://github.com/boto/boto3)



  Base class inherited by all the others.  Manages connections to AWS via
  access keys or profiles.



  CloudFormation client



  CloudWatch client



  Access to IAM functions - mainly for user access key management.

  Can raise an `AccessKeyError` exception on failure.

  ```
  from ccaaws.iamclient import IamClient

  iam = IamClient("iam.user")
  newkey = iam.rotateKeys()
  ```



  SSM ParameterStore client

  [modeline]: # ( vim: set ft=markdown tw=74 fenc=utf-8 spell spl=en_gb mousemodel=popup: )


pkgId: b8705d1353915aa64b1c75466ded3c8e8c2b33f9658da9968c21c6f9a0caef97
name: python-ccard
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: credit card generator
url: https://github.com/davidsamir/credit-card-generator/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccard-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Fake credit-card generator
  is a Python 3 Package for TESTING PURPOSES AND DATA VERIFICATION ONLY!
  Instead of using a real credit card
  this tool will help you generate a vaild credit card numbers
  Giving you the option to generate the following type of credit card
  - Visa
  - Discover
  - Master Card
  - American Express


pkgId: 4c5ddfcfffcf2a94220d745e2ef04b342fb4b4e8f405b25d500be8842e1fa368
name: python-ccbuilder
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A clang/gcc compiler builder
url: https://github.com/DeadCodeProductions/ccbuilder
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccbuilder-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Basic Usage:
  ```
  ccbuilder build [compiler] [revision]
  ```
  `compiler` must be either `llvm` or `gcc` and `revision` either a commit hash
  or a tag.
  `ccbuilder` relies on clones the GCC and LLVM git repos and can build most of their recent revisions/commits/tags, e.g.,
  `ccbuilder build gcc releases/gcc-13.1.0` will build GCC 13.1.0.
  The built compilers are installed under `ccbuilder`'s compiler store (a filesystem directory).
  After building a compiler, its installation location is printed, e.g.:
  ```
  % ccbuilder build llvm main
  /path/to/ccbuilder_compiler_store/clang-ff7d2fabe074d95cefb683d4a742eec172bd36d5
  % /path/to/ccbuilder_compiler_store/clang-ff7d2fabe074d95cefb683d4a742eec172bd36d5/bin/clang -v
  clang version 18.0.0 (https://github.com/llvm/llvm-project.git ff7d2fabe074d95cefb683d4a742eec172bd36d5)
  ```
  `ccbuilder` stores everything under `$HOME/.cache`, the default locations can
  be overriden via command line flags, e.g., `ccbuilder build llvm master --compiler-store-path /some/other/path`
  To update the compiler git repos use `ccbuilder --pull`.


pkgId: e47f5fe92f7bd35afb86bd5f5c27ae42060aac277a3181f3ae3e71a955fe09fd
name: python-cccs-yara
arch: src
version: 2.5
epoch: 0
release: 1
summary: A CCCS utility for YARA rule metadata validation
url: https://pypi.org/project/cccs-yara/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cccs-yara-2.5-1.src.rpm
checksum_type: sha256
description:
  The [CCCS YARA Specification](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA.yml) has been created to define and validate the style and format of YARA rule metadata. It comes with a cli which allow you to validate and generate metadata automatically (such as unique id, rule fingerprint, actor enrichment from ATT&CK).

  Over the years we have seen many YARA rules; in order to leverage them to their full potential we always had to modify some of their associated metadata, even for rules we developed ourselves. Adjusting simple elements such as datetime format and adding important information to help analysts.

  You can leverage it in your CI/CD pipeplines to automatically verify and enrich your Yara rules before new rules are merged in!

  This specification also include fields specific to the [MITRE ATT&CK framework](https://attack.mitre.org/matrices/enterprise/) to identify techniques and universal [MITRE ATT&CK threat groups](https://attack.mitre.org/groups/).

  [AssemblyLine](https://www.cyber.gc.ca/en/assemblyline) supports this specification natively and will leverage it to provide more context around YARA signature hits.

  [vscode-yara](https://github.com/infosec-intern/vscode-yara) creates a custom meta section that aligns with this specification, using the User or Workspace settings file, `settings.json`. See [settings.json](settings.json) for an example.



  ```
  rule MemoryModule {
      meta:
  	id = "6O9mUMvPhziJ72IXHf6muZ"
  	fingerprint = "4aa0a23f28698898404d700cb363ddf06dd275f5798815e797113656a2a40ae8"
  	version = "1.0"
  	date = "2020-05-06"
  	modified = "2020-05-06"
  	status = "RELEASED"
  	sharing = "TLP:WHITE"
  	source = "CCCS"
  	author = "analyst@CCCS"
  	description = "Yara rule to detect usage of MemoryModule Library"
  	category = "TECHNIQUE"
  	technique = "LOADER:MEMORYMODULE"
  	mitre_att = "T1129"
  	report = "TA20-0192"
  	hash = "812bbe8b9acabad05b08add50ee55c883e1f7998f3a7cae273d3f0d572a79adc"

      strings:
          $func_ptr =    {55 8B EC 6A 00 68 [3] 00 68 [3] 00 68 [3] 00 68 [3] 00 68 [3] 00}
          $func_ptr_64 = {48 [3] 48 [4] 00 00 00 00 48 8? [5] 48 8? [3] 4? 8? [5] 48 8? [3-5] 48 8?}
          $api_1 = "LoadLibraryA"
          $api_2 = "GetProcAddress"
          $api_3 = "FreeLibrary"
          $api_4 = "VirtualFree"
          $api_5 = "VirtualProtect"
          $api_6 = "VirtualAlloc"

      condition:
          uint16(0) == 0x5a4d and all of ($api*) and ($func_ptr or $func_ptr_64)
  }
  ```



  - https://github.com/reversinglabs/reversinglabs-yara-rules
  - https://github.com/bartblaze/Yara-rules
  - https://github.com/0xThiebaut/Signatures



  validator.py: This is the validator library. It is used to validate the metadata section of YARA rules. It verifies specified metadata information, auto-generates some of metadata information and re-sorts the metadata information into the canonical order with all 'unknown' metadata information appended to the bottom.

  - [CCCS_YARA.yml](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA.yml): This is the definition of the CCCS YARA Standard in the YAML format. (Limitation: This file is provided to show what fields are expected, currently the yara_validator doeSn't use this file directly, this will be addressed in a future release.)

  - [CCCS_YARA_values.yml](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA_values.yml): File which describe the list of acceptable values for fields defined in the CCCS_YARA.yml

  yara_validator: This is a command line interface utility. It takes a file, list of files, a folder looking for files with the .yar or .yara extension.



  Python 3.6+

  All required python packages are in the requirements.txt

  The [Cyber Threat Intelligence Repository](https://github.com/mitre/cti) is a submodule of this repository:

  ```
  git clone https://github.com/CybercentreCanada/CCCS-Yara.git
  cd CCCS-Yara
  pip install  .
  ```



  ```
  yara_validator -h
       ____ ____ ____ ____   __   __ _    ____      _
      / ___/ ___/ ___/ ___|  \ \ / // \  |  _ \    / \
     | |  | |  | |   \___ \   \ V // _ \ | |_) |  / _ \
     | |__| |__| |___ ___) |   | |/ ___ \|  _ <  / ___ \
      \____\____\____|____/    |_/_/   \_\_| \_\/_/   \_\

  usage: yara_validator [-h] [-r] [-n] [-v] [-vv] [-f] [-w] [-s] [-st]
                               [-m] [-i | -c]
                               paths [paths ...]

  CCCS YARA script to run the CCCS YARA validator, use the -i or -c flags to
  generate the id, fingerprint, version, first_imported, or last_modified (if
  not already present) and add them to the file.

  positional arguments:
    paths                A list of files or folders to be analyzed.

  optional arguments:
    -h, --help           show this help message and exit
    -r, --recursive      Recursively search folders provided.
    -n, --no-changes     Makes no changes and outputs potential results to the
                         output.
    -v, --verbose        Verbose mode, will print why a rule was invalid.
    -vv, --very-verbose  Very-verbose mode, will printout what rule is about to
                         be processed, the invalid rules, the reasons they are
                         invalid and all contents of the rule.
    -f, --fail           Fail mode, only prints messages about invalid rules.
    -w, --warnings       This mode will ignore warnings and proceed with other
                         behaviors if the rule is valid.
    -s, --standard       This prints the YARA standard to the screen.
    -st, --strict        This causes the cli to return a non-zero exit code for
                         warnings.
    -m, --module         This flag overrides the check for modules that have not
                         been imported.
    -i, --in-place       Modifies valid files in place, mutually exclusive with
                         -c.
    -c, --create-files   Writes a new file for each valid file, mutually
                         exclusive with -i.
  ```

  Quick example:

  ```

  python yara_validator -v -i <path>
  ```





  La [Spécification YARA du CCCS](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA.yml) a été créé pour définir et validé le style et le format des attributs pour les règles YARA. Un outil ligne de commandes permet de valider et généré les tags automatiquement!

  Au fil des années nous avons vu beaucoup de régles YARA; mais pour pouvoir les utilisées à leur plein potentiel nous devions modifiée les méta données associtiées, parfois même pour nos propres règles. En ajustant des éléments aussi simples que le format de date et en ajoutant des attributs important pour les analystes.

  Ce standard pour les méta données inclus aussi des champs spécifique au [MITRE ATT&CK framework](https://attack.mitre.org/matrices/enterprise/) pour identifier les techniques et les groups d'acteurs [MITRE ATT&CK threat groups](https://attack.mitre.org/groups/).

  [AssemblyLine](https://www.cyber.gc.ca/fr/chaine-de-montage-assemblyline) supporte cette spécification nativement et l'utilisera pour fournir d'avantage d'information à l'utilisateur lors du déclanchement d'une signature.



  ```
  rule MemoryModule {
      meta:
  	id = "6O9mUMvPhziJ72IXHf6muZ"
  	fingerprint = "4aa0a23f28698898404d700cb363ddf06dd275f5798815e797113656a2a40ae8"
  	version = "1.0"
  	date = "2020-05-06"
  	modified = "2020-05-06"
  	status = "RELEASED"
  	sharing = "TLP:WHITE"
  	source = "CCCS"
  	author = "analyst@CCCS"
  	description = "Yara rule to detect usage of MemoryModule Library"
  	category = "TECHNIQUE"
  	technique = "LOADER:MEMORYMODULE"
  	mitre_att = "T1129"
  	report = "TA20-0192"
  	hash = "812bbe8b9acabad05b08add50ee55c883e1f7998f3a7cae273d3f0d572a79adc"

      strings:
          $func_ptr =    {55 8B EC 6A 00 68 [3] 00 68 [3] 00 68 [3] 00 68 [3] 00 68 [3] 00}
          $func_ptr_64 = {48 [3] 48 [4] 00 00 00 00 48 8? [5] 48 8? [3] 4? 8? [5] 48 8? [3-5] 48 8?}
          $api_1 = "LoadLibraryA"
          $api_2 = "GetProcAddress"
          $api_3 = "FreeLibrary"
          $api_4 = "VirtualFree"
          $api_5 = "VirtualProtect"
          $api_6 = "VirtualAlloc"

      condition:
          uint16(0) == 0x5a4d and all of ($api*) and ($func_ptr or $func_ptr_64)
  }
  ```



  - https://github.com/reversinglabs/reversinglabs-yara-rules
  - https://github.com/bartblaze/Yara-rules



  validator.py: La librairie de validation. Elle permet de vérifier si une règle YARA a tous les attributs nécessaires, elle auto-génère aussi certain attribut et les ordonnent selon l'ontologie. Tous les attributs supplémentaires ne faisant pas partie de la spécification sont placé à la fin.

  - [CCCS_YARA.yml](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA.yml): Fichier de de définition de la spécification. (Limitation: Ce fichier démontre les attributs nécessaires, présentement le validateur n'utilise pas se fichier directement, ceci sera améliorer dans le futur.)

  - [CCCS_YARA_values.yml](https://github.com/CybercentreCanada/CCCS-Yara/blob/master/CCCS_YARA_values.yml): Fichier qui décrit les valeurs acceptables pour chacun des attributs définit dans CCCS_YARA.yml.

  yara_validator: Utilitaire de validation pour la ligne de commande. Il accepte une règle, une liste de règles ou un dossier pour validé les fichiers se terminant par .yar ou .YARA.



  Python 3.6+

  Tous les libraries python sont dans le fichier requirements.txt

  [Cyber Threat Intelligence Repository](https://github.com/mitre/cti) est un sous module de ce répertoire:

  ```
  git clone https://github.com/CybercentreCanada/CCCS-Yara.git
  cd CCCS-Yara
  pip install  .
  ```



  ```
  yara_validator -h
       ____ ____ ____ ____   __   __ _    ____      _
      / ___/ ___/ ___/ ___|  \ \ / // \  |  _ \    / \
     | |  | |  | |   \___ \   \ V // _ \ | |_) |  / _ \
     | |__| |__| |___ ___) |   | |/ ___ \|  _ <  / ___ \
      \____\____\____|____/    |_/_/   \_\_| \_\/_/   \_\

  usage: yara_validator [-h] [-r] [-n] [-v] [-vv] [-f] [-w] [-s] [-st]
                               [-m] [-i | -c]
                               paths [paths ...]

  CCCS YARA script to run the CCCS YARA validator, use the -i or -c flags to
  generate the id, fingerprint, version, first_imported, or last_modified (if
  not already present) and add them to the file.

  positional arguments:
    paths                A list of files or folders to be analyzed.

  optional arguments:
    -h, --help           show this help message and exit
    -r, --recursive      Recursively search folders provided.
    -n, --no-changes     Makes no changes and outputs potential results to the
                         output.
    -v, --verbose        Verbose mode, will print why a rule was invalid.
    -vv, --very-verbose  Very-verbose mode, will printout what rule is about to
                         be processed, the invalid rules, the reasons they are
                         invalid and all contents of the rule.
    -f, --fail           Fail mode, only prints messages about invalid rules.
    -w, --warnings       This mode will ignore warnings and proceed with other
                         behaviors if the rule is valid.
    -s, --standard       This prints the YARA standard to the screen.
    -st, --strict        This causes the cli to return a non-zero exit code for
                         warnings.
    -m, --module         This flag overrides the check for modules that have not
                         been imported.
    -i, --in-place       Modifies valid files in place, mutually exclusive with
                         -c.
    -c, --create-files   Writes a new file for each valid file, mutually
                         exclusive with -i.
  ```


pkgId: 5fbdf06579e19d9989763214161b865c25f815c9362088db2bda14d5bd77d92e
name: python-ccdexplorer-fundamentals
arch: src
version: 0.2.35
epoch: 0
release: 1
summary: Shared code for CCDExplorer.io and its Notification Bot.
url: https://github.com/ccdexplorer/ccdexplorer-fundamentals
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccdexplorer-fundamentals-0.2.35-1.src.rpm
checksum_type: sha256
description:
  This repository hosts the shared code used by many of the other repositories in the CCD Explorer Universe. The only way I knew how to make this work (locally and in Docker containers), is by publishing this repo as a Python package.

  Most important modules in the repo are:
  * GRPCClient: this is the partial Python SDK that contains all relevant GRPC types and methods to request information from the GRPC endpoint from a node.
  * MongoDB: this module contains the connection to the MongoDB instance (or replicaset). See the [Mongo Type Docs](/docs/mongo_types_docs.md) for more information.
  * Tooter: this module is a light wrapper around [Apprise](https://github.com/caronc/apprise), used to send notifications.
  * CIS: this module contains logic to decode CIS-2 events according to the [CIS-2 Specifications](http://proposals.concordium.software/CIS/cis-2.html#cis-2-functions-tokenmetadata). This module is used in token accounting. See the [CIS Type Docs](/docs/cis_types_docs.md) for more information.




  This module is implemented as a partial Python SDK for the GRPC endpoint for a node. As such, it needs to be updated regularly whenever new types and methods are added to the [GRPC Protocol Documentation](http://developer.concordium.software/concordium-grpc-api/). It relies heavily on [BetterProto](https://github.com/danielgtaylor/python-betterproto), however only version 2.0.0b6 seems to work. Hence, run
  ```
  pip install "betterproto[compiler]"==2.0.0b6
  ```
  to install this version.

  BetterProto takes the `.proto` files from the [Concordium GRPC Api Repo](https://github.com/Concordium/concordium-grpc-api/tree/main/v2/concordium) and converts this into the neccesary classes. When an update is performed on the Concordium GRPC Api Repo, copy the new files to the same location and run the following command:

  ```
  python -m grpc_tools.protoc -I. --python_out=. --pyi_out=. --grpc_python_out=. --python_betterproto_out=. service.proto
  ```

  This will generate the new `_pb2.py(i)` files.


  When I started with this project, I didn't know the first thing about Protobuf. To be honest, I still don't, but I *have* found a way to manage this by creating my own classes, mirroring the classes as generated by the `types.proto` file . These classes are stored in a submodule called `CCD_Types`. This contains 165 classes and 55 type aliases. See the [GRPC Type Docs](/docs/grpc_types_docs.md) for more information.


  The services in the `service.proto` file are mirrored in the `queries` submodule, where all relevant GRPC calls are built. These are the methods that other services call to retrieve specific information from the node.

  For every call to the node, it calls `grpc.channel_ready_future` to check if the service is ready (the node is able to respond to queries). Is this somehow fails, the module tries to connect to a different node (as supplied in the `ENV` variables).




  Almost none of the modules in this repo as useful as a standalone package, with the exception of the GRPC SDK.



  ```
  NOTIFIER_API_TOKEN (API token for notifier bot)
  API_TOKEN (API token for actual bot)
  FASTMAIL_TOKEN (I use Fastmail to send email, leave blank, won't send email)
  MONGO_URI (MongoDB URI)
  ADMIN_CHAT_ID (Telegram admin chat ID)
  MAILTO_LINK (I use Fastmail to send email, leave blank, won't send email)
  MAILTO_USER (I use Fastmail to send email, leave blank, won't send email)
  GRPC_MAINNET (A list of dicts with GPRC hosts) (Example: [{"host": "localhost", "port": 20000}, {"host": "my.validator.com", "port": 20000}])
  GRPC_TESTNET (Same as GPRC_MAINNET)
  ```



  The CIS module and GRPC module have associated tests.


  * **explorer.ccd** - *Everything*



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


pkgId: ad1538b2d8ffad28a8ba7612553020371cca714a2cb9f2c837cb0fcfa9326ca0
name: python-ccdt
arch: src
version: 2.1.128
epoch: 0
release: 1
summary: AI数据转换工具箱
url: https://github.com/chipeak/chipeak_cv_data_tool
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccdt-2.1.128-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="resources/LOGO.png" width="450"/>
    <center>

    [![PyPI](https://img.shields.io/badge/pypi-v1.0.0-blue)](https://pypi.org/project/ccdt/)
    [![license](https://img.shields.io/badge/license-GNU%20General%20Public%20License-green)](https://github.com/540717421/chipeak_cv_data_tool/blob/main/LICENSE)

    </center>
  </div>



  简体中文| [English](README_EN.md)

  &nbsp;&nbsp;&nbsp;&nbsp;chipeak_cv_data_tool主要用于多种数据集(计算机视觉)格式之间的相互转换,如coco、labelme等。另外还集成数据、文件、视频等文件常用的处理功能。



  1. 集成多种计算机视觉标注格式相互转换
  2. 支持各类数据集的筛选,分配与切割
  3. 集成多种文件、图像、视频处理功能
  4. 模块可拓展,用户可自定义数据格式
  5. 提供python模块包,命令行等便捷方式



  pip install ccdt


  请参考[快速入门文档](docs/get_started.md)学习 chipeak_cv_data_tool 的基本使用。



  labelme:https://github.com/wkentaro/labelme


  * 数据支持集格式：
      - [x] labelme格式数据集 https://github.com/wkentaro/labelme
      - [x] COCO格式数据集
  * 数据处理功能：
      - [x] 数据集标注文件相互转换
      - [x] 截取目标保存为图像(目前支持:矩形框,)
  * 图像(文件)处理：
      - [x] 按比例或者文件数目划分数据(列如:文件分配或者训练测试集划分)
  * 视频处理：
      - [x] 视频切片成图像
      - [x] 图像合成为视频


  * 数据支持集格式：
      - [x] labelme格式数据集 https://github.com/wkentaro/labelme
      - [x] COCO格式数据集
  * 数据处理功能：
      - [x] 数据集标注文件相互转换
      - [x] 截取目标保存为图像(目前支持:矩形框,)
  * 图像(文件)处理：
      - [x] 按比例或者文件数目划分数据(列如:用于文件分配或者训练测试集划分)
  * 视频处理：
      - [x] 视频切片成图像
      - [x] 图像合成为视频



  该项目采用 [GNU General Public License v3.0 开源许可证](LICENSE)。



  最新的月度版本 v1.0 在 2021.11.08 发布。

  已支持的数据集：

  - [x] COCO数据集
  - [x] Via标注数据集
  - [x] Labelme标注数据集


  已更新的功能：

  - [x] labelme数据集抠图
  - [x] coco数据集转labelme数据集
  - [x] labelme数据集转coco数据集
  - [x] 根据标签类别筛选labelme数据集



  无



  无



  ```
  @misc{ccdt2021,
    author =       {詹勇},
    title =        {{ccdt: Annotation conversion and file video processing tools}},
    howpublished = {url{https://github.com/chipeak/chipeak_cv_data_tool.git}},
    year =         {2023}
  }
  ```


  - [ccdt](https://github.com/540717421/chipeak_data_tool): chipeak_cv_data_tool AI数据处理工具箱




  扫描下方的二维码可关注 芯峰科技团队的 [官方网站](http://http://www.chipeak.com/)，加入芯峰科技 团队的 [官方交流](http://www.chipeak.com/account/login)
  <div align="center">
  <img src="/resources/xf_rq_code.png" height="200" />
  </div>
  我们会在 ChiPeak 社区为大家

  - 📢 分享 AI 框架的前沿核心技术
  - 💻 解读 ccdt 常用模块源码
  - 📰 发布 ChiPeak 的相关新闻
  - 🚀 介绍 ChiPeakDetection 开发的前沿算法
  - 🏃 获取更高效的问题答疑和意见反馈
  - 🔥 提供与各行各业开发者充分交流的平台

  干货满满 📘，等你来撩 💗，ChiPeak 社区期待您的加入 👬


  [![Security Status](https://www.murphysec.com/platform3/v31/badge/1673251865674670080.svg)](https://www.murphysec.com/console/report/1673251865636921344/1673251865674670080)


pkgId: 373cf6a8ef2f6a63560e66d30ba0f5351f8c22dfa4fa6bca0dbc13f132ebd924
name: python-ccfit2
arch: src
version: 5.9.0
epoch: 0
release: 1
summary: CCFIT2 is a program for fitting AC and DC magnetisation data
url: https://gitlab.com/chilton-group/cc-fit2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccfit2-5.9.0-1.src.rpm
checksum_type: sha256
description:
  `ccfit2` is a package for working with magnetometry data, specifically those from AC susceptibility, DC decay, and DC Waveform measurements.

  Although the main use of `ccfit2` is to extract and later fit temperature/field dependent relaxation rate data from these experiments, the modular nature
  of `ccfit2` means that the user is free to include any of `ccfit2`'s functionality in their own work.



  To get started, head to the online documentation for `ccfit2` [here](https://chilton-group.gitlab.io/cc-fit2/).



  Install in editable mode by running

  ```
  pip install -e .
  ```

  in the repository HEAD.



  We request that any data processed with `ccfit2` is accompanied by the version number (obtained with `pip show ccfit2`)  and **both** of the following citations

  1. William J. A. Blackmore, Gemma K. Gransbury, Peter Evans, Jon G. C. Kragskow, David P. Mills, and Nicholas F. Chilton. Characterisation of magnetic relaxation on extremely long timescales. Phys. Chem. Chem. Phys., 2023, 25, 16735-16744. URL: https://dx.doi.org/10.1039/d3cp01278f

  2. Daniel Reta and Nicholas F. Chilton. Uncertainty estimates for magnetic relaxation times and magnetic relaxation parameters. 	Phys. Chem. Chem. Phys., 2019, 21, 23567-23575. URL: https://dx.doi.org/10.1039/C9CP04301B


pkgId: 972b4cc78805be35ce4a0a527867665e5ea38c09b54aeb3de49de764904729a7
name: python-ccflow
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Composable Configuration Flow
url: https://github.com/point72/ccflow
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccflow-0.4.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/point72/ccflow">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://github.com/point72/ccflow/raw/main/docs/img/dark.png?raw=true">
      <img alt="ccflow logo, 'ccflow' with letters in color" src="https://github.com/point72/ccflow/raw/main/docs/img/light.png?raw=true" width="400">
    </picture>
  </a>

  <br/>
  <br/>

  [![Build Status](https://github.com/Point72/ccflow/actions/workflows/build.yml/badge.svg?branch=main&event=push)](https://github.com/Point72/ccflow/actions/workflows/build.yml)
  [![GitHub issues](https://img.shields.io/github/issues/point72/ccflow.svg)](https://github.com/point72/ccflow/issues)
  [![PyPI Version](https://img.shields.io/pypi/v/ccflow.svg)](https://pypi.python.org/pypi/ccflow)
  [![License](https://img.shields.io/pypi/l/ccflow.svg)](https://github.com/Point72/ccflow/blob/main/LICENSE)

  `ccflow` is a collection of tools for workflow configuration, orchestration, and dependency injection.
  It is intended to be flexible enough to handle diverse use cases, including data retrieval, validation, transformation, and loading (i.e. ETL workflows), model training, microservice configuration, and automated report generation.

  The framework provides:

  - a way to manage hierarchical, strongly typed configurations and the relationships between them through composition
  - a way to associate user-defined functions with configurations, and in doing so, to define and name configurable workflow graphs
  - a way to manage dependency injection and inversion of control for objects in these graphs
  - flexibility in how to interact with configurations and workflows, including files/command line, native python/Jupyter notebook, Airflow/job scheduler, REST API, etc (in progress)

  It heavily leverages [pydantic](https://docs.pydantic.dev/latest/), and users are expected to implement their own configuration and workflow building blocks by implementing pydantic models.

  It also integrates closely with [hydra](https://hydra.cc/) for file-based configuration and command line interaction, but can also be used natively from Python without it.

  This library was partially inspired by this [blog post](https://towardsdatascience.com/configuration-management-for-model-training-experiments-using-pydantic-and-hydra-d14a6ae84c13) by Suneeta Mall ([@suneeta-mall](https://github.com/suneeta-mall)).
  We have taken these ideas a step further by introducing the concept of the `ModelRegistry`, which allows for the configs to be managed without `hydra`, and also allows us to implement dependency injection.

  We aim to provide additional (and optional) tools for workflow orchestration on top of the configuration framework.

  [More information is available in our wiki](https://github.com/Point72/ccflow/wiki)



  `ccflow` can be installed via [pip](https://pip.pypa.io) or [conda](https://docs.conda.io/en/latest/), the two primary package managers for the Python ecosystem.

  To install `ccflow` via **pip**, run this command in your terminal:

  ```bash
  pip install ccflow
  ```

  To install `ccflow` via **conda**, run this command in your terminal:

  ```bash
  conda install ccflow -c conda-forge
  ```



  - [Contribute](https://github.com/Point72/ccflow/wiki/Contribute) to `ccflow` and help improve the project



  This software is licensed under the Apache 2.0 license. See the [LICENSE](https://github.com/Point72/ccflow/blob/main/LICENSE) file for details.

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


pkgId: 9876bd99d36eb3706a7e109ec9399a93b334d0387d46b0a9147ffc491ae78f50
name: python-ccfx
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Your package description here
url: https://github.com/celray/ccfx
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccfx-0.3.0-1.src.rpm
checksum_type: sha256
description:
  `ccfx` is a comprehensive Python package designed to streamline file and data management, geospatial analysis, and NetCDF file processing for quick prototyping. The library provides versatile tools for file handling, raster and vector manipulation, database connectivity, and data export for geospatial and scientific computing projects.



  1. **File Management**:
     - List, delete, move, and count files within directories.
     - Monitor file count over time in a specific directory.
     - Save, load, and manage Python variables via pickle serialization.

  2. **Geospatial Data Processing**:
     - Read, write, and manage raster and vector geospatial data.
     - Clip rasters by bounding boxes and extract raster values at specified coordinates.
     - Create grids of polygons based on shapefile boundaries with user-defined resolutions.
     - Convert coordinates between coordinate reference systems (CRS).
     - Write NumPy arrays to GeoTIFF files with projection and geotransform settings.

  3. **NetCDF File Handling**:
     - List available variables and dimensions in NetCDF files.
     - Export NetCDF variables to GeoTIFF format.
     - Calculate sum and average maps from NetCDF data across multiple files.

  4. **Database Connectivity**:
     - Access and interact with databases using ODBC and SQLAlchemy for flexible database management.
     - Connect to both SQL Server and SQLite databases.

  5. **Progress Tracking and System Info**:
     - Display dynamic progress bars for long-running operations.
     - Check the system’s platform information.
     - Enable or disable warnings programmatically.

  6. **Excel and Word File Handling**:
     - Create and modify Excel files using xlsxwriter.
     - Generate Word documents with advanced formatting options using python-docx.



  Install `ccfx` via pip:
  ```bash
  pip install ccfx
  ```



  `ccfx` relies on the following libraries:

  - **netCDF4**: For working with NetCDF files.
  - **gdal**: Required for geospatial raster data manipulation.
  - **numpy**: For array processing and numerical operations.
  - **pandas**: For data manipulation and analysis.
  - **shapely**: Provides geometric operations for spatial data.
  - **geopandas**: Extends pandas to handle geospatial data.
  - **xlsxwriter**: For creating and writing Excel files.
  - **pyodbc**: Enables connectivity to databases through ODBC.
  - **sqlalchemy**: Provides SQL toolkit and ORM features for database access.
  - **python-docx**: Enables creation and manipulation of Word documents.

  These dependencies will be installed automatically when `ccfx` is installed.




  Lists all files in a directory with a specified extension.

  - **Parameters**:
    - `path` (str): The directory to search.
    - `ext` (str, optional): File extension to filter by, e.g., `'txt'`, `'.txt'`, `'*txt'`, or `'*.txt'`.

  - **Returns**:
    - `list`: A list of file paths matching the criteria.


  Deletes a specified file with optional verbose output.

  - **Parameters**:
    - `filePath` (str): Path to the file to be deleted.
    - `v` (bool, optional): If `True`, prints a confirmation message. Defaults to `False`.

  - **Returns**:
    - `bool`: `True` if deletion was successful; `False` otherwise.


  Generates a grid of polygons from a shapefile at a given resolution.

  - **Parameters**:
    - `shapefile_path` (str): Path to the shapefile.
    - `resolution` (float): Resolution of the grid.
    - `useDegree` (bool, optional): If `True`, coordinates are in degrees. Defaults to `True`.

  - **Returns**:
    - `tuple`: Contains grid coordinates and metadata.


  Clips a raster to specified bounding box coordinates.

  - **Parameters**:
    - `inFile` (str): Path to the input raster file.
    - `outFile` (str): Path to the output clipped raster file.
    - `bounds` (tuple): Bounding box as `(minx, miny, maxx, maxy)`.

  - **Returns**:
    - `str`: Path to the clipped raster file.


  Lists all variables in a NetCDF file.

  - **Parameters**:
    - `ncFile` (str): Path to the NetCDF file.

  - **Returns**:
    - `list`: A list of variable names in the file.





  Contributions are welcome! Please fork the repository, make your changes, and submit a pull request.


  This project is licensed under the MIT License.


pkgId: b95a563003483811cae47360f0c9d162b5327aecd788a8c1d576e5af916354eb
name: python-ccg-logging
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: A package for function-driven logging.
url: https://pypi.org/project/ccg-logging/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccg-logging-1.4.2-1.src.rpm
checksum_type: sha256
description:
  A package for function-driven logging.

  The ethos of `ccg_logging` is to have all logging within a project driven by
  function calls and function outputs.

  No explicit log statements need inserting - just the addition of the `log_function_call`
  decorator onto any and all functions that you want to log.


pkgId: e73cd972ab53401eda6ad6058c8a81bb03d57e053b0616344d05d60ae215dc0a
name: python-cchdo.params
arch: src
version: 2024.10.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://cchdo.ucsd.edu/
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cchdo.params-2024.10.1-1.src.rpm
checksum_type: sha256
description:
  The spun off master cchdo parameters list including the following:

  * Exchange WHP names and units
  * CF names and units
  * Mappings between WHP Units and udunits compatable ones
  * netcdf variable names for humans


pkgId: 4d6a34138acc966c1f637f51b637996846bee4ce7ef7293c930cb505977212e6
name: python-cchdo.params
arch: src
version: 2024.12.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://cchdo.ucsd.edu/
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cchdo.params-2024.12.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cchdo.params)
  [![SPEC 0 — Minimum Supported Dependencies](https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/spec-0000/)


  The spun off master cchdo parameters list including the following:

  * Exchange WHP names and units
  * CF names and units
  * Mappings between WHP Units and udunits compatable ones
  * netcdf variable names for humans


pkgId: 6d26ca77f2169cf4f5df106f866cf7d48cba7ea717ef17acb33666928041a080
name: python-ccheck
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A human-friendly framework for testing and evaluating LLMs, RAGs, and chatbots.
url: https://github.com/Addepto/contextcheck
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccheck-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ![ContextCheck Logo](https://raw.githubusercontent.com/Addepto/contextcheck/main/docs/contextcheck_logo_violet.png)



  A human-friendly framework for testing and evaluating LLMs, RAGs, and chatbots.

  **ContextCheck** is an open-source framework designed to evaluate, test, and validate large language models (LLMs), Retrieval-Augmented Generation (RAG) systems, and chatbots. It provides tools to automatically generate queries, request completions, detect regressions, perform penetration tests, and assess hallucinations, ensuring the robustness and reliability of these systems. ContextCheck is configurable via YAML and can be integrated into continuous integration (CI) pipelines for automated testing.



  - [Features](https://github.com/Addepto/contextcheck#features)
  - [Installation](https://github.com/Addepto/contextcheck#installation)
    - [For Users](https://github.com/Addepto/contextcheck#for-users)
    - [For Developers](https://github.com/Addepto/contextcheck#for-developers)
  - [Tutorial](https://github.com/Addepto/contextcheck#tutorial)
  - [CLI Features](https://github.com/Addepto/contextcheck#cli-features)
    - [Output Test Results to Console](https://github.com/Addepto/contextcheck#output-test-results-to-console)
    - [Running in CI/CD](https://github.com/Addepto/contextcheck#running-in-cicd)
  - [Contributing](https://github.com/Addepto/contextcheck#contributing)
    - [Running Tests](https://github.com/Addepto/contextcheck#running-tests)
  - [Acknowledgments](https://github.com/Addepto/contextcheck#acknowledgments)
  - [License](https://github.com/Addepto/contextcheck#license)




  - **Simple test scenario definition** using human-readable `.yaml` files
  - **Flexible endpoint configuration** for OpenAI, HTTP, and more
  - **Customizable JSON request/response models**
  - **Support for variables and Jinja2 templating** in YAML files
  - **Response validation** options, including heuristics, LLM-based judgment, and human labeling
  - **Enhanced output formatting** with the `rich` package for clear, readable displays






  Install the package directly from PyPI using pip:

  ```sh
  pip install ccheck
  ```

  After installation, you can access the `ccheck` CLI command:

  ```sh
  ccheck --help
  ```

  This will display all available options and help you get started with using ContextCheck.



  If you wish to contribute to the project or modify it for your own use, you can set up a development environment using Poetry.

  1. Fork your own copy of Addepto/contextcheck on GitHub.
  2. Clone the Repository:
    ```sh
    git clone https://github.com/<your_username>/contextcheck.git
    cd contextcheck
    ```
  3. Ensure you have [Poetry](https://python-poetry.org/) installed.
  4. Install Dependencies:
    ```sh
    poetry install
    ```
  5. Activate the Virtual Environment:
    ```sh
    poetry shell
    ```
  6. Activate the `ccheck` CLI command using:
    ```sh
    poetry run ccheck --help
    ```




  Please refer to `examples/` folder for the tutorial.






  - **Run a single scenario and output results to the console:**
    ```sh
    ccheck --output-type console --filename path/to/file.yaml
    ```
  - **Run multiple scenarios and output results to the console:**
    ```sh
    ccheck --output-type console --filename path/to/file.yaml path/to/another_file.yaml
    ```



  To automatically stop the CI/CD process if any tests fail, add the `--exit-on-failure` flag. Failed test will cause the script to exit with code 1:

  ```sh
  ccheck --exit-on-failure --output-type console --folder my_tests
  ```

  Use env variable `OPENAI_API_KEY` to be able to run:
  - `tests/scenario_openai.yaml`
  - `tests/scenario_defaults.yaml`




  Contributions are welcomed!



  To run tests:
  ```
  poetry run pytest tests/
  ```

  To include tests which require calling LLM APIs (currently OpenAI and Ollama), run one of:
  ```
  poetry run pytest --openai          # includes tests that use OpenAI API
  poetry run pytest --ollama          # includes tests that use Ollama API
  poetry run pytest --openai --ollama # includes tests that use both OpenAI and Ollama API
  ```




  Made with ❤️ by the Addepto Team

  ContextCheck is an extension of the [ContextClue](https://context-clue.com/) product, created by the [Addepto](https://addepto.com/) team. This project is the result of our team’s dedication, combining innovation and expertise.

  Addepto Team:

  * Radoslaw Bodus
  * Bartlomiej Grasza
  * Volodymyr Kepsha
  * Vadym Mariiechko
  * Michal Tarkowski

  Like what we’re building? ⭐ Give it a star to support its development!




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


pkgId: 2c917bfd7406974c02232f935e1afde4e80b7615392f90d12bef270623571b23
name: python-ccl-scratch-tools
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Tools with which to work with Scratch JSON files.
url: https://github.com/GSE-CCL/scratch-tools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccl-scratch-tools-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/ccl-scratch-tools/badge/?version=latest)](https://ccl-scratch-tools.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.com/GSE-CCL/scratch-tools.svg?branch=master)](https://travis-ci.com/GSE-CCL/scratch-tools)


  A Python package with which to work with Scratch JSON files, from the Creative Computing Lab at the Harvard Graduate School of Education.



  Make sure you have Python 3.7 or higher. Then install the package by running ```pip install ccl-scratch-tools```.

  Check it out on PyPI: [https://pypi.org/project/ccl-scratch-tools/](https://pypi.org/project/ccl-scratch-tools/).



  Read the documentation of the package [here](https://ccl-scratch-tools.readthedocs.io/en/latest/).


  [https://github.com/LLK/scratch-rest-api/wiki/](https://github.com/LLK/scratch-rest-api/wiki/) for API documentation


pkgId: 8c20f864a5c97c20d26da2ae0dd4100f40ada197f7fd45e32095a04bf6e59517
name: python-ccm
arch: src
version: 3.1.5
epoch: 0
release: 1
summary: Cassandra Cluster Manager
url: https://github.com/riptano/ccm
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccm-3.1.5-1.src.rpm
checksum_type: sha256
description:
  A script/library to create, launch and remove an Apache Cassandra cluster on
  localhost.
  The goal of ccm and ccmlib is to make it easy to create, manage and destroy a
  small Cassandra cluster on a local box. It is meant for testing a Cassandra cluster.


pkgId: f976e5bc1e88ba06232d67e94c7b80f249495ef2e73d90055eccafd591e24b79
name: python-ccnmtldjango
arch: src
version: 1.11.0
epoch: 0
release: 1
summary: Paste template for Django development at CCNMTL
url: https://github.com/ccnmtl/ccnmtldjango/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccnmtldjango-1.11.0-1.src.rpm
checksum_type: sha256
description:
  Setting up a fresh checkout
  The first time you check out an existing ccnmtl-template project from
  svn/git:
       $ make


pkgId: 72c7acaddb228c1ff7454fd37d23333d2e973142f4aae6971f9583f50684dd03
name: python-cconf
arch: src
version: 0.9.9
epoch: 0
release: 1
summary: Multi-sourced (and optionally encrypted) configuration management.
url: https://github.com/imsweb/cconf
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cconf-0.9.9-1.src.rpm
checksum_type: sha256
description:
  `cconf` is a library for reading configuration from various sources (such as environment
  variables, environment files, and environment directories) and optionally encrypting
  sensitive configurations. Sensitive configuration values are encrypted using
  [Fernet](https://cryptography.io/en/latest/fernet/) tokens, which provide authenticated
  crypography and the ability to specify a maximum valid lifetime (`ttl`).




  `pip install cconf`

  To use `Fernet` keys for encrypting sensitive settings, `cconf` requires the
  [cryptography](https://cryptography.io/) module, which can be installed as an extra:

  `pip install cconf[fernet]`




  By default, there is a `config` singleton set up to read configuration from the process
  environment variables (`os.environ`):

  ```python
  from cconf import config

  DEBUG = config("DEBUG", False, cast=bool)
  ```

  You can add to the list of configuration sources (this will still read from `os.environ`
  first):

  ```python
  from cconf import config

  config.file("/path/to/.env")
  config.dir("/path/to/envdir")
  ```

  Or you may want to set the configuration sources (and their order) manually. The
  following will try `envdir` first, followed by `.env`.

  ```python
  from cconf import config

  config.setup("/path/to/envdir", "/path/to/.env")
  ```

  You can also specify sources that have `keys`, which can be the path to a file with
  `Fernet` keys, one per line, or a list of `str|bytes` keys that will be converted to
  `Fernet` keys:

  ```python
  from cconf import config, EnvDir, EnvFile, HostEnv

  config.setup(
      EnvDir("/path/to/envdir", keys="/path/to/envdir.keys"),
      EnvFile("/path/to/.env", keys="/path/to/env.keys"),
      HostEnv(keys=["WQ6g4VBia1fNCuVCrsX5VvGUWYlHssUJLshONLsivhc="]),
  )
  ```



  Any configuration value can be marked as `sensitive`, meaning it must be encrypted (or
  base64-encoded if not using `Fernet` keys) and will never be read from a plaintext
  source.

  ```python
  from cconf import config, Secret

  config.file("/path/to/.env", keys="/path/to/secret.key")


  SECRET_KEY = config("SECRET_KEY", sensitive=True, cast=Secret, ttl=86400)
  ```

  Setting a `ttl` will ensure the encrypted value is no older than that number of seconds.
  Values older than `ttl` will emit a warning and return `undefined`. You may set a
  default value for a `sensitive` config value, but a warning will be emitted.

  To get started, you can use the `cconf` CLI tool to generate a new `Fernet` key, then
  use that key to encrypt some data:

  ```
  % cconf genkey > secret.key
  % cconf encrypt --keyfile secret.key secretdata
  ```

  If you've already generated a key and configured the sources with that key in your
  settings file, you may also pass `-c/--config` to `cconf`:

  ```
  % cconf -c myapp.settings encrypt secretdata
  ```

  This will encrypt the string `secretdata` using all encrypted sources in your config,
  and output them along with the source they're encrypted for. You must add this data to
  your configuration files manually, `cconf` makes no attempt to write to these files for
  you.




  A source may specify a key file policy (`keys=cconf.KeyFile(name, policy=...)`) which
  performs additional checks when opening the key file. By default `KeyFile.policy` is
  set to `cconf.UserOnly`, which checks that the key file is owned by the current user,
  and has no permissions granted to group or other users (i.e. `600` mode).

  Similarly, `EnvFile` and `EnvDir` sources accept a `policy` argument (which defaults to
  `None`) that will perform policy checks when opening the environment files. You may set
  this to `cconf.UserOnly` or `cconf.UserOrGroup`, or write your own policy. A policy is
  simply a function that takes a single `path` argument and raises `cconf.PolicyError` if
  the file should not be opened.




  The `cconf` CLI tool includes a `check` command which will print out a list of
  configuration variables it knows about, grouped by the source. For instance, running it
  against the `tests.settings.prod` module of a local checkout will produce something that
  looks like this:

  ```
  % python -m cconf.cli -c tests.settings.prod check
  EnvFile(/Users/dcwatson/Projects/cconf/tests/envs/prod)
      HOSTNAME
          'prodhost'
      USERNAME
          'produser'
      API_KEY
          'prodkey'
  EnvDir(/Users/dcwatson/Projects/cconf/tests/envdirs/prod)
      PASSWORD
          'cc0nfRul3z!'
  (Default)
      DEBUG
          'false'
  ```



  `cconf` will emit warnings (specifically `ConfigWarning`, a subclass of `UserWarning`)
  in certain cases:

  * A config value was marked as `sensitive`, but the value extracted from the
    configuration source has either expired (if a `ttl` was specified), or is improperly
    encrypted (wrong key, plaintext, etc.)
  * A config value was marked as `sensitive`, but was not found in any of the sources and
    a default value is being used.
  * A config key was not found in any of the sources, and there is no default value
    specified. In this case, `undefined` is returned and a warning is emitted.

  You may choose to silence these warnings, or promote them to exceptions using Python's
  `warnings` module:

  ```python
  import warnings
  from cconf import ConfigWarning


  warnings.simplefilter("ignore", ConfigWarning)


  warnings.simplefilter("error", ConfigWarning)
  ```




  `cconf` includes a single management command that wraps the `cconf` CLI tool. To use it,
  add `cconf` to your `INSTALLED_APPS` setting, then run `manage.py config`. Being a
  management command means your settings are already imported, so you don't need to
  constantly pass `-c myproject.settings` to the `cconf` CLI.


pkgId: a33423299b6d33e4a167c575c23559d4d58fa2f06ed5de8ce9623aaa5d4e9c0f
name: python-ccontext
arch: src
version: 0.3.2
epoch: 0
release: 1
url: https://github.com/NicolasArnouts/ccontext
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccontext-0.3.2-1.src.rpm
checksum_type: sha256
summary:
  collect-context: Makes the process of collecting and sending context to an LLM like ChatGPT-4o as easy as possible.

description:
  Feel free to raise issues or contribute to the project. We appreciate your support!
  **Nicolas Arnouts**
  [arnouts.software@gmail.com](mailto:arnouts.software@gmail.com)


pkgId: 5f2a20212b98468b4be7f5489af9ec81e1c33d5682ac9cb74e6304ca9a1df9e4
name: python-ccorp-yaml-include-relative-path
arch: src
version: 0.0.4
epoch: 0
release: 1
url: https://github.com/marsoloGit/ccorp_yaml_include
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccorp-yaml-include-relative-path-0.0.4-1.src.rpm
checksum_type: sha256
summary:
  Exactly ccorp-yaml-include package with a bug fix and support of relative paths for included aliases

description:
  This package is exactly ccorp-yaml-include package(a fork of ccorp-yaml-include) that contains a bug fix (init of YAML didn't accept a 'typ' kwargs that was a list)
  It also allows to use `!include` tag with a relative path for aliases, e.g.
  instead of just writing:
  <br> *!include bear_common.yaml* <br>(which means that bear_common.yaml should be located in the same directory as your yaml file)

  you can have:
  <br>*!include ../common_data/bear_common.yaml* <br>(which means that bear_common.yaml in now located in a separate folder 'common_data')
  - **version 0.0.4**: a bug related to ExcludingConstructor.construct_sequence() method to miss a parameter called 'deep', fixed.


pkgId: 6d5d7515df858af4f19df0194af724007ca9455dcc39b24845c4a8cfef51c511
name: python-ccpem-utils
arch: src
version: 0.0.1.dev31
epoch: 0
release: 1
summary: "Python utils for EM data processing (dev version)"
url: https://gitlab.com/ccpem/ccpem-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccpem-utils-0.0.1.dev31-1.src.rpm
checksum_type: sha256
description:
  Python utility functions for EM data processing


  Install directly from PyPI with:
  ``pip install ccpem-utils``
  OR
  Download from the gitlab repo and navigate into the `ccpem-utils` directory and
  install `ccpem-utils` with the command:

  ``pip install -e .``


pkgId: dafa1a9b2145460ea0a3f0eb7a5e4baf4f22772a57cf7b149f6b0581c3f79d64
name: python-ccpn-project-checker
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: A project checker for ccpn v3+ projects
url: https://pypi.org/project/ccpn-project-checker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccpn-project-checker-0.1.17-1.src.rpm
checksum_type: sha256
description:
  platform darwin -- Python 3.10.13, pytest-8.1.1, pluggy-1.4.0 -- /Users/garyt/Library/Application Support/pipx/venvs/ccpn-project-checker/bin/python
  cachedir: .pytest_cache
  rootdir: /Users/garyt/Library/Application Support/pipx/venvs/ccpn-project-checker/lib/python3.10/site-packages/ccpn_project_checker/tests
  plugins: time-machine-2.14.1
  collected 58 items
  test_api.py::test_memops_checker_read_protected[READ_PROTECTED_PROJECT] PASSED                                                                                       [  1%]


pkgId: a090fd0645c6f4668dca0190e233e507547a1a36f69b1df3fb924129f3cacfd8
name: python-ccptools
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: The CCP Tools team utilities for date and/or time objects and values and messing with types.
url: https://github.com/ccpgames/ccptools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccptools-1.2.0-1.src.rpm
checksum_type: sha256
description:
  A smooshup of a few Python packages from the CCP Tools Team of old (Team
  Batcave).

  Our two most commonly used internal packages, called `datetimeutils` and
  `typeutils` were too _generically_ named for Pypi.org and since they were
  both used in something like 80-90% of our other projects, it made sense to
  just smoosh them together in one module, and thus, the `ccptools` package
  was born.

  Here's the README of the [Date Time Utils](./ccptools/dtu/README.md) submodule.

  Here's the README of the [Type Utils](./ccptools/tpu/README.md) submodule.




  The old `datetimeutils` package is now included here as the `dtu` submodule.

  ```python
  from ccptools import dtu
  ```



  The name has been shortened to `dtu` to speed up usage _(although you can
  also just go `from ccptools.dtu import *` if you wish)_.

  The code has also been quite heavily refactored but everything that was
  available in `datetimeutils` 2.3.0.0 should be accessible via `ccptools.legacyapi.datetimeutils`.

  That is, for a super low-effort upgrade from older `datetimeutils` version
  to the new `ccptools` package, simply replace...:

  ```python
  import datetimeutils
  ```

  ...with...

  ```python
  from ccptools.legacyapi import datetimeutils
  ```

  ...and everything should work fine! :)

  Note that any Python 2.7 support has been removed.



  The name has been shortened to `tpu` although that's more to fit in with the
  `dtu` pattern. It shouldn't really matter since `typeutils` was rarely if
  ever imported directly since it was split into multiple submodules from the
  start.

  Nevertheless to accommodate any changed from `typeutils` 3.5.0.0 and ease
  migration over to `ccptools` the old API is aliased in
  `ccptools.legacyapi.typeutils`.

  So you can simply replace

  ```python
  from typeutils import metas
  ```

  ...with...

  ```python
  from ccptools.legacyapi.typeutils import metas
  ```

  ...and everything should work fine! :)

  Note that any Python 2.7 support has been removed.



  Importing `*` from the `structs` submodule will import all of the most
  commonly used imports in our projects:
  ```python
  from typing import *  # For type annotation

  import abc  # For interfaces (Abstract Base Classes)
  import dataclasses  # For dataclass structs
  import decimal  # Used whenever we're handling money
  import enum  # Also used for struct creation
  import logging  # Used pretty much everywhere
  import re  # Used surprisingly frequently
  import time  # Very commonly used
  ```

  Note that datetime is not included in this. That's because tt'll also import
  the aliases from the Datetime Utils (`ccptools.dtu.structs.aliases`)
  package instead:

  ```python
  Date = datetime.date
  Time = datetime.time
  Datetime = datetime.datetime
  TimeDelta = datetime.timedelta
  TzInfo = datetime.tzinfo
  TimeZone = datetime.timezone
  ```

  Furthermore, it'll also include a few of the most commonly used utility
  classes from the Type Utils submodule:

  - The `Singleton` Meta Class
  - The `Empty` and `EmptyDict` classes as well as the `if_empty` method
  - The `EnumEx` base class for Enums with the `from_any` class method

  So in most cases we can cover something like 90% of any imports we tend to
  need in every Python file with a single line:

  ```python
  from ccptools.structs import *
  ```

rpm_license:
  MIT License  Copyright (c) 2013-2024 CCP Games  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: dc33ff76787c28c568592d9188a47aa6a1e47aa8828f7371d28cefd2a25df6b6
name: python-ccs-digitalmarketplace-apiclient
arch: src
version: 29.0.0
epoch: 0
release: 1
summary: API clients for Digital Marketplace Data API and Search API.
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-apiclient
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccs-digitalmarketplace-apiclient-29.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  ![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-apiclient.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-apiclient)

  API clients for Digital Marketplace [Data API](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-api) and
  [Search API](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-search-api).
  Originally was part of [Digital Marketplace Utils](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-utils).

  Install Python dependencies:
  ```
  make bootstrap
  invoke requirements-dev
  ```
  Run the tests:
  ```
  invoke test
  ```

  ```python
  data_client = apiclient.DataAPIClient(api_url, api_access_token)
  services = data_client.find_services_iter(framework=frameworks)
  ```

  To update the package version, edit the `__version__ = ...` string in `dmapiclient/__init__.py`,
  commit and push the change and wait for CI to create a new version tag.
  Once the tag is available on GitHub, the new version can be used by the apps by adding the following
  line to the app `requirements.txt` (replacing `X.Y.Z` with the current version number):
  ```
  git+https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-apiclient.git@X.Y.Z#egg=ccs-digitalmarketplace-apiclient==X.Y.Z
  ```
  When changing a major version number consider adding a record to the `CHANGELOG.md` with a
  description of the change and an example of the upgrade process for the client apps.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: a801407bb13839274ce798d629724626f4c18ca704083b27dd9127413e1649f3
name: python-ccs-digitalmarketplace-content-loader
arch: src
version: 13.0.0
epoch: 0
release: 1
summary: Digital Marketplace Content Loader
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-content-loader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccs-digitalmarketplace-content-loader-13.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-content-loader.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-content-loader)

  Content loader for Digital Marketplace.
  Originally was part of [Digital Marketplace Utils](https://github.com/Crown-Commercial-Service/digitalmarketplace-utils).

  Install Python dependencies
  ```
  make bootstrap
  invoke requirements-dev
  ```
  Run the tests
  ```
  invoke test
  ```

  To update the package version, edit the `__version__ = ...` string in `dmcontent/__init__.py`,
  once merged the new version will be released and published to [PyPI](https://pypi.org/project/digitalmarketplace-content-loader/) by [Github Actions](./.github/workflows).
  When changing a major version number consider adding a record to the `CHANGELOG.md` with a
  description of the change and an example of the upgrade process for the client apps.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: e25b7e1fe4b209fc8f1e348791688f8eb6851abe5b40abf8316f7570c3ef40de
name: python-ccs-digitalmarketplace-frontend-jinja
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Jinja templates for Digital Marketplace apps.
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-frontend-jinja
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccs-digitalmarketplace-frontend-jinja-3.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-frontend-jinja.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-frontend-jinja)
  This repository provides a complete set of [Jinja](https://jinja.palletsprojects.com/) macros that are kept up-to-date and 100% compliant with [CCS Digital Marketplace GOV.UK Frontend](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend) Nunjucks macros. Porting is intentionally manual rather than automated to make updates simpler than maintaining an automated conversion routine. A comprehensive test suite ensures compliance against the latest, and every subsequent, CCS GOV.UK Frontend Frontend release.
  This project was inspired by the [GOV.UK Frontend Jinja Macros](https://github.com/LandRegistry/govuk-frontend-jinja) project by [HM Land Registry](https://github.com/LandRegistry) and we thank them for their work which has helped with this project.

  The following table shows the version of Digital Marketplace Frontend Jinja that you should use for your targeted version of CCS Digital Marketplace GOV.UK Frontend:
  | Digital Marketplace Frontend Jinja Version | Target CCS Digital Marketplace GOV.UK Frontend Version |
  | ------------------------------------------ | ------------------------------------------------------ |
  | [3.0.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/3.0.1) | [2.0.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v2.0.2) |
  | [2.10.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.10.0) | [1.3.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.3.1) |
  | [2.9.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.9.0) | [1.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.2.0) |
  | [2.8.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.8.0) | [1.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.1.0) |
  | [2.7.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.7.0) | [1.0.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.0.0) |
  | [2.6.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.6.0) | [6.4.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.4.0) |
  | [2.5.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.5.0) | [6.3.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.3.0) |
  | [2.2.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.2.0) | [6.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.2.0) |
  | [2.1.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.1.1) | [6.1.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.1.1) |
  | [2.1.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.1.0) | [6.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.1.0) |
  | [2.0.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.0.0) | [6.0.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.0.0) |
  | [1.4.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.4.1) | [5.5.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.5.0) |
  | [1.4.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.4.0) | [5.5.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.5.0) |
  | [1.3.3](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.3) | [5.4.3](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.3) |
  | [1.3.2](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.2) | [5.4.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.2) |
  | [1.3.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.1) | [5.4.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.1) |
  | [1.3.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.0) | [5.4.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.0) |
  | [1.2.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.2.0) | [5.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.2.0) |
  | [1.1.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.1.0) | [5.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.2.0) |
  | [1.0.2](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.2) | [5.1.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.2) |
  | [1.0.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.1) | [5.1.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.1) |
  | [1.0.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.0) | [5.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.0) |
  Any other versions of CCS Digital Marketplace GOV.UK Frontend not shown above _may_ still be compatible, but have not been specifically tested and verified.

  After running `pip install ccs-digitalmarketplace-frontend-jinja`, ensure that you tell Jinja where to load the templates from using the `PackageLoader` as follows:
  ```python
  from flask import Flask
  from jinja2 import ChoiceLoader, PackageLoader, PrefixLoader
  app = Flask(__name__)
  app.jinja_loader = ChoiceLoader(
      [
          PackageLoader("app"),
          PrefixLoader(
            {
              "govuk_frontend_jinja": PackageLoader("govuk_frontend_jinja"),
              "digitalmarketplace_frontend_jinja": PackageLoader("digitalmarketplace_frontend_jinja"),
            }
          ),
      ]
  )
  ```

  To use a component in your project templates you must import and call the component macro and pass the relevant options, for example:
  ```html
  { from 'digitalmarketplace_frontend_jinja/components/alert/macro.html' import digitalmarketplaceAlert -%}
  {{ digitalmarketplaceAlert({
      "titleText": "Your application is complete",
      "text": "You still have 3 unsubmitted services",
      "type" : "success"
  }) }}
  ```
  The options available to each component macro can be found in the original [CCS Digital Marketplace GOV.UK Frontend](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/tree/main/packages/digitalmarketplace-frontend/src/digitalmarketplace/components) documentation. Since this project is a like-for-like port, the only difference between the Nunjucks examples and their Jinja equivalents is having to quote key names, e.g. `'text'` instead of `text`.

  Releases of this project follow [semantic versioning](http://semver.org/), ie
  > Given a version number MAJOR.MINOR.PATCH, increment the:
  >
  > - MAJOR version when you make incompatible API changes,
  > - MINOR version when you add functionality in a backwards-compatible manner, and
  > - PATCH version when you make backwards-compatible bug fixes.
  To make a new version:
  - update the version in the `digitalmarketplace_frontend_jinja/__init__.py` file
  - if you are making a major change, also update the change log;
  When the pull request is merged a GitHub Action will tag the new version.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 7789c9f62af2478b03106592ff01ef105283c319c72f452e9aa68f3af3cfe82a
name: python-ccs-digitalmarketplace-utils
arch: src
version: 69.0.0
epoch: 0
release: 1
summary: Common utils for Digital Marketplace apps.
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccs-digitalmarketplace-utils-69.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  ![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-utils.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-utils)

  * Digital Marketplace API clients
  * Formatting utilities for Digital Marketplace
  * Digital Marketplace logging for Flask using JSON Logging
  * Utility functions/libraries for Amazon S3, Mailchimp, Notify, Cloudwatch
  * Helper code for Flask configuration
  * A formed version of Flask Feature Flags

  When logging from applications you should write your message as a [format
  string](https://docs.python.org/2/library/string.html#format-string-syntax) and pass any required
  arguments to the log method in the `extra` named argument. This allows our logging to use them as
  separate fields in our JSON logs making it much easier to search and aggregate on them.
  ```python
  logger.info("the user {user_id} did the thing '{thing}'", extra={
      'user_id': user_id, 'thing': thing
  })
  ```
  Note that apart from not getting the benefit, passing the formatted message can be dangerous. User
  generated content may be passed, unescaped to the `.format` method.

  Releases of this project follow [semantic versioning](http://semver.org/), ie
  > Given a version number MAJOR.MINOR.PATCH, increment the:
  >
  > - MAJOR version when you make incompatible API changes,
  > - MINOR version when you add functionality in a backwards-compatible manner, and
  > - PATCH version when you make backwards-compatible bug fixes.
  To make a new version:
  - update the version in the `dmutils/__init__.py` file
  - if you are making a major change, also update the change log;
  When the pull request is merged a GitHub Action will tag the new version.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 297d0d5fcbc36ee56a8e0bc63ae216606369f48995673aab271ea8da5bbf46ea
name: python-ccs-fit
arch: src
version: 0.22.5
epoch: 0
release: 1
summary: Fitting tools for repulsive two body interactions using curvature constrained splines.
url: https://github.com/Teoroo-CMC/CCS
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccs-fit-0.22.5-1.src.rpm
checksum_type: sha256
description:
  ![](logo.png)
  The `CCS_fit` package is a tool to construct two-body potentials using the idea of curvature constrained splines.


  ```
  ccs_fit-x.y.z
  ├── CHANGELOG.md
  ├── LICENSE
  ├── MANIFEST.in
  ├── README.md
  ├── bin
  │   ├── ccs_build_db
  │   ├── ccs_export_sktable
  |   ├── ccs_export_FF
  │   ├── ccs_fetch
  │   ├── ccs_fit
  │   └── ccs_validate
  ├── docs
  ├── examples
  │   └── Basic_Tutorial
  │       └── tutorial.ipynb
  │   └── Advanced_Tutorials
  │       ├── CCS
  │       ├── CCS_with_LAMMPS
  │       ├── DFTB_repulsive_fitting
  │       ├── ppmd_interfacing
  │       ├── Preparing_ASE_db_trainingsets
  │       ├── Search_mode
  │       └── Simple_regressor
  ├── logo.png
  ├── poetry.lock
  ├── pyproject.toml
  ├── src
  │   └── ccs
  │       ├── ase_calculator
  │       ├── common
  │       ├── data
  │       ├── debugging_tools
  │       ├── fitting
  │       ├── ppmd_interface
  │       ├── regression_tool
  │       └── scripts
  │           ├── ccs_build_db.py
  │           ├── ccs_export_FF.py
  │           ├── ccs_export_sktable.py
  │           ├── ccs_fetch.py
  │           ├── ccs_fit.py
  │           └── ccs_validate.py
  └── tests
  ```
  * `ccs_build_db`        - Routine that builds an ASE-database.
  * `ccs_fetch`           - Executable to construct the traning-set (structures.json) from a pre-existing ASE-database.
  * `ccs_fit`             - The primary executable file for the ccs_fit package.
  * `ccs_export_sktable`  - Export the spline in a dftbplus-compatible layout.
  * `ccs_export_FF`       - Fit the spline to commonly employed force fields; Buckingham, Morse and Lennard Jones.
  * `ccs_validate`        - Validation of the energies and forces of the fit compared to the training set.
  * `main.py`             - A module to parse input files.
  * `objective.py`        - A module which contains the objective function and solver.
  * `spline_functions.py` - A module for spline construction/evaluation/output.
  <!---

  You need to install the following softwares
  ```
  pip install numpy
  pip install scipy
  pip install ase
  pip install cvxopt
  ```


  ```
  git clone git@github.com/Teoroo-CMC/CCS.git
  cd CCS
  python setup.py install


pkgId: ae0321e50b71548de9938a3128ecce516ab8fe2d065ee2c7a2d457deee4a880d
name: python-ccsdspy
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: IO Interface for Reading CCSDS Data in Python.
url: https://pypi.org/project/ccsdspy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccsdspy-1.3.2-1.src.rpm
checksum_type: sha256
description:
  This community-developed package provides a Python interface for reading tightly packed bits in the `Consultative Committee for Space Data Systems (CCSDS) <https://public.ccsds.org/>`__ format used by many NASA and ESA missions. The library is developed with requirements sourced from the community and extensive automated testing.

rpm_license:
  Copyright (c) 2018, Daniel da Silva All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * Neither the name of the ccsdspy project 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: a1ef3abac16581ae80b64a16c94405583bd8318a24a0ef9653183654f3198eb6
name: python-cctk
arch: src
version: 0.2.25
epoch: 0
release: 1
summary: computational chemistry toolkit
url: https://github.com/ekwan/cctk
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cctk-0.2.25-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cctk.svg)](https://pypi.python.org/pypi/cctk/)
  [![Anaconda version](https://anaconda.org/conda-forge/cctk/badges/version.svg)](https://anaconda.org/conda-forge/cctk)
  [![Doc status](https://readthedocs.org/projects/pip/badge/)](https://cctk.rtfd.io)
  [![Downloads](https://img.shields.io/pypi/dm/cctk.svg)](https://pypi.python.org/pypi/cctk/)

  *a Python-based computational chemistry toolkit*

  *cctk* simplifies the computational modeling of organic reactions and small molecule structures by automating routine interactions with quantum chemistry software packages:

   - **input file creation**: conformer enumeration, job keyword manipulations, constrained potential energy surface creation
   - **method screening**: creating jobs that screen grids of DFT methods and basis sets
   - **job monitoring**: identification of job status, progress of optimizations, and resubmission of failed jobs
   - **data extraction**: geometries, energies, molecular properties (e.g. charges or NMR shieldings), or geometric parameters (distances, angles, dihedrals) from output files
   - **data analysis**: easy export for statistical analysis or visualization

  A quick-start guide is [available](https://cctk.readthedocs.io/en/latest/quick-start.html). More documentation is [here](https://cctk.readthedocs.io/).

  *cctk* is primarily designed for use with [Gaussian 16](https://gaussian.com). Some support is provided for other file formats (`.xyz`, `.mol2`, `.pdb`, [Schrodinger](https://www.schrodinger.com) `mae`, and [Orca](https://sites.google.com/site/orcainputlibrary/) `.inp`/`.out`).





  *cctk* is easy to install! It should work on any system where Python works.

  With Python 3.6 or later, type:

  ```
  pip install cctk
  ```

  or

  ```
  conda install -c conda-forge cctk
  ```

  If you don't have [pip](https://pypi.org/project/pip/) or virtual environments available on your system, then we recommend installing Anaconda first:

  1. Go to [https://www.anaconda.com/distribution/](https://www.anaconda.com/distribution/). Download the Python 3 installer appropriate to your system and run it.

  2. Create a virtual environment to use with *cctk* (with whatever version of Python you prefer):

   ```
   conda create --name cctk python=3.8
   ```

  3. Now activate the virtual environment:

   ```
   conda activate cctk
   ```

  To use *cctk*, you will need to place this command at the beginning of your Python scripts:

  ```
  import cctk
  ```

  The [documentation](https://cctk.readthedocs.io/) contains many examples of how to write *cctk* scripts.



  *cctk* is undergoing active development. To upgrade to the latest stable release:

  ```
  pip install --upgrade cctk
  ```

  To install the development version, which may be unstable, run:

  ```
  $ pip install --upgrade git+git@github.com:ekwan/cctk.git@master
  ```

  Alternatively, clone the repository. Then, from within the repository folder, run:

  ```
  pip install --upgrade .
  ```



  If you want to read the *cctk* documentation locally, you can build it by going to the `docs` folder and typing:

  ```
  make html
  ```

  This command will require the `sphinx` and `sphinx-bootstrap-theme` packages to be installed first. Once generated, the documentation will be available locally at: `docs/_build/html/index.html`.





  - `cctk/` contains the Python modules for *cctk* and the accompanying static data files.
  - `docs/` contains the code needed to generate the documentation.
  - `scripts/` contains pre-defined scripts that use *cctk* to quickly analyze and manipulate one or many output files.
  - `test/` contains code to test *cctk* and accompanying files.
  - `tutorial/` contains detailed tutorials on how to use *cctk* on complex, real-world problems.

  *cctk* requires Python 3.7+, [`numpy`](https://numpy.org/), and [`networkx`](https://networkx.github.io/).
  A full list of requirements can be found in `env.yml`.



  *cctk* depends on some external data (`cctk/data/`):

  - Atomic weights are taken from the
  [NIST website](https://physics.nist.gov/cgi-bin/Compositions/stand_alone.pl?ele=&all=all&ascii=ascii2&isotype=some)
  and stored in `cctk/data/isotopes.csv`.
  - Covalent radii are taken from
  [*Dalton Trans.* **2008**, 2832](https://pubs.rsc.org/en/content/articlelanding/2008/dt/b801115j#!divAbstract)
  and stored in `cctk/data/covalent_radii.csv`.
  (When multiple atomic types were specified, the one with longer bond distances was adopted for simplicity).
  - van der Waals radii were taken from
  [*J. Am. Chem. Soc.* **1983**, *105*, 5220](https://pubs.acs.org/doi/10.1021/ja00354a007),
  [*Inorg. Mater.* **2001**, *37*, 871](https://link.springer.com/article/10.1023/A:1011625728803), and
  [*J. Phys. Chem. A*, **2009**, *113*, 5806](https://pubs.acs.org/doi/10.1021/jp8111556) and stored in `cctk/data/vdw_radii.csv`.



  *cctk* is an ongoing project led by Corin Wagen and Eugene Kwan.

  There is a Slack workspace for *cctk* users and developers: please email ``cwagen@g.harvard.edu`` or ``ekwan16@gmail.com`` for access.



  Wagen, C.C.; Kwan, E.E. *cctk* **2020**, [www.github.com/ekwan/cctk](https://www.github.com/ekwan/cctk).



  This project is licensed under the Apache License, Version 2.0.  Please see `LICENSE` for full terms and conditions.

  *Copyright 2020 by Corin Wagen and Eugene Kwan*


pkgId: ca96f168830bd4d0240714682cb64eda6cff9520b36c8046322349e5c8b5d47d
name: python-cctx
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A JavaScript / Python / PHP cryptocurrency trading library with support for 90+ exchanges
url: https://ccxt.trade
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cctx-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Oops!
  Looking for CCXT? You've mistyped the name. Bad guys could exploit this, providing a fake version of CCXT here, but we always think a step forward :) So here's the original version you've might been looking for: https://www.npmjs.com/package/ccxt
  Have a nice day!
  – CCXT Dev Team


pkgId: 2d81a9bf0559345d99d5c497e661a03d0bede11e71e62926c7d5f94d0a0b22e8
name: python-cctyper
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: CRISPRCasTyper: Automatic detection and subtyping of CRISPR-Cas operons
url: https://github.com/Russel88/CRISPRCasTyper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cctyper-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Project Status: Active - The project has reached a stable, usable state and is being actively developed.](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
  [![Conda](https://anaconda.org/russel88/cctyper/badges/installer/conda.svg)](https://anaconda.org/russel88/cctyper)



  Detect CRISPR-Cas genes and arrays, and predict the subtype based on both Cas genes and CRISPR repeat sequence.

  [CRISPRCasTyper and RepeatType are also available through a webserver](https://crisprcastyper.crispr.dk)

  This software finds Cas genes with a large suite of HMMs, then groups these HMMs into operons, and predicts the subtype of the operons based on a scoring scheme.
  Furthermore, it finds CRISPR arrays with [minced](https://github.com/ctSkennerton/minced) and by BLASTing a large suite of known repeats, and using a kmer-based machine learning approach (extreme gradient boosting trees) it predicts the subtype of the CRISPR arrays based on the consensus repeat.
  It then connects the Cas operons and CRISPR arrays, producing as output:
  * CRISPR-Cas loci, with consensus subtype prediction based on both Cas genes (mostly) and CRISPR consensus repeats
  * Orphan Cas operons, and their predicted subtype
  * Orphan CRISPR arrays, and their predicted associated subtype


  * I-A, I-B, I-C, I-D, I-E, I-F, I-F (transposon), I-G, II-A, II-B, II-C, III-A, III-B, III-C, III-D, III-E, III-F, IV-A1, IV-A2, IV-A3, IV-B, IV-C, IV-D, IV-E, V-A, V-B1, V-B2, V-C, V-D, V-E, V-F1, V-F2, V-F3, V-F (the rest), V-G, V-H, V-I, V-J, V-K, V-L, VI-A, VI-B1, VI-B2, VI-C, VI-D, VI-X, VI-Y.

  * All subtypes from the most recent Nature Reviews Microbiology (Makarova et al. 2020): [Evolutionary classification of CRISPR–Cas systems: a burst of class 2 and derived variants](https://doi.org/10.1038/s41579-019-0299-x)
  * Updated type IV subtypes and variants based on: [Type IV CRISPR–Cas systems are highly diverse and involved in competition between plasmids](https://doi.org/10.1093/nar/gkz1197)
  * Type V-K: [RNA-guided DNA insertion with CRISPR-associated transposases](https://doi.org/10.1126/science.aax9181)
  * Transposon associated type I-F: [Transposon-encoded CRISPR–Cas systems direct RNA-guided DNA integration](https://doi.org/10.1038/s41586-019-1323-z)
  * New V-A variants: [Novel Type V-A CRISPR Effectors Are Active Nucleases with Expanded Targeting Capabilities](https://doi.org/10.1089/crispr.2020.0043)
  * New Cas13s: [Programmable RNA editing with compact CRISPR–Cas13 systems from uncultivated microbes](https://doi.org/10.1038/s41592-021-01124-4)
  * V-L (cas12l): [A new family of CRISPR-type V nucleases with C-rich PAM recognition](https://doi.org/10.15252/embr.202255481)



  <img src='img/plot.svg' align="left" height="200" />


  [Jakob Russel, Rafael Pinilla-Redondo, David Mayo-Muñoz, Shiraz A. Shah, Søren J. Sørensen - CRISPRCasTyper: Automated Identification, Annotation and Classification of CRISPR-Cas loci. The CRISPR Journal Dec 2020](https://doi.org/10.1089/crispr.2020.0059)

  Find a free to read version on [BioRxiv](https://doi.org/10.1101/2020.05.15.097824)


  1. [Quick start](#quick)
  2. [Installation](#install)
  3. [CRISPRCasTyper - How to](#cctyperhow)
      * [Plotting](#plot)
  4. [RepeatType - How to](#repeattype)
      * [Updated models](#repeatnew)
  5. [RepeatType - Train](#repeattrain)
  6. [Troubleshoot](#trouble)



  ```sh
  conda create -n cctyper -c conda-forge -c bioconda -c russel88 cctyper
  conda activate cctyper
  cctyper my.fasta my_output
  ```


  CRISPRCasTyper can be installed either through conda or pip.

  It is advised to use conda, since this installs CRISPRCasTyper and all dependencies, and downloads the database in one go.


  Use [miniconda](https://docs.conda.io/en/latest/miniconda.html) or [anaconda](https://www.anaconda.com/) to install.

  Create the environment with CRISPRCasTyper and all dependencies and database
  ```sh
  conda create -n cctyper -c conda-forge -c bioconda -c russel88 cctyper
  ```


  If you have the dependencies (Python >= 3.8, HMMER >= 3.2, Prodigal >= 2.6, minced, grep, sed) in your PATH you can install with pip

  Install cctyper python module
  ```sh
  python -m pip install cctyper
  ```

  Upgrade cctyper python module to the latest version
  ```sh
  python -m pip install cctyper --upgrade
  ```



  ```sh

  svn checkout https://github.com/Russel88/CRISPRCasTyper/trunk/data
  tar -xvzf data/Profiles.tar.gz
  mv Profiles/ data/
  rm data/Profiles.tar.gz



  export CCTYPER_DB="/path/to/data/"

  cctyper input.fa output --db /path/to/data/
  ```


  CRISPRCasTyper takes as input a nucleotide fasta, and produces outputs with CRISPR-Cas predictions


  ```sh
  conda activate cctyper
  ```


  ```sh
  cctyper genome.fa my_output
  ```


  ```sh
  cctyper genome.fa my_output --circular
  ```


  The default prodigal mode expects the input to be a single draft or complete genome
  ```sh
  cctyper assembly.fa my_output --prodigal meta
  ```


  ```sh
  cctyper -h
  ```


  * **CRISPR_Cas.tab:**           CRISPR_Cas loci, with consensus subtype prediction
      * Contig: Sequence accession
      * Operon: Operon ID (Sequence accession @ NUMBER)
      * Operon_Pos: [Start, End] of operon
      * Prediction: Consenus prediction based on both Cas operon and CRISPR arrays
      * CRISPRs: CRISPRs adjacent to Cas operon
      * Distances: Distances to CRISPRs from Cas operon
      * Prediction_Cas: Subtype prediction based on Cas operon
      * Prediction_CRISPRs: Subtype prediction of CRISPRs based on CRISPR repeat sequences
  * **cas_operons.tab:**          All certain Cas operons
      * Contig: Sequence accession
      * Operon: Operon ID (Sequence accession @ NUMBER)
      * Start: Start of operon
      * End: End of operon
      * Prediction: Subtype prediction
      * Complete_Interference: Percent completion of the interference module(s). Can be a list if best_type is a list (Hybrid and Ambiguous)
      * Complete_Adaptation: Percent completion of the adaptation module(s). Can be a list if best_type is a list (Hybrid and Ambiguous)
      * Best_type: Subtype with the highest score. If the score is high then Prediction = Best_type
      * Best_score: Score of the highest scoring subtype
      * Genes: List of Cas genes
      * Positions: List of Gene IDs for the genes
      * E-values: List of E-values for the genes
      * CoverageSeq: List of sequence coverages for the genes
      * CoverageHMM: List of HMM coverages for the genes
      * Strand_Interference: Strand of interference module. 1 is positive strand, -1 is negative strand, 0 is mixed, NA if no interference gene found
      * Strand_Adaptation: Strand of adaptation module. 1 is positive strand, -1 is negative strand, 0 is mixed, NA if no adaptation gene found
  * **crisprs_all.tab:**          All CRISPR arrays, also false positives
      * Contig: Sequence accession
      * CRISPR: CRISPR ID (minced: Sequence accession _ NUMBER; repeatBLAST: Sequence accession - NUMBER _ NUMBER)
      * Start: Start of CRISPR
      * End: End of CRISPR
      * Consensus_repeat: Consensus repeat sequence
      * N_repeats: Number of repeats
      * Repeat_len: Length of repeat sequences
      * Spacer_len_avg: Average spacer length
      * Repeat_identity: Average identity of repeat sequences
      * Spacer_identity: Average identity of spacer sequences
      * Spacer_len_sem: Standard error of the mean of spacer lenghts
      * Trusted: TRUE/FALSE, is the array trusted. Based on repeat/spacer identity, spacer sem, prediction probability and adjacency to a cas operon
      * Prediction: Prediction of the associated subtype based on the repeat sequence
      * Subtype: Subtype with highest prediction probability. Prediction = Subtype if Subtype_probability is high
      * Subtype_probability: Probability of subtype prediction
  * **crisprs_near_cas.tab:**     CRISPRs part of CRISPR-Cas loci
      * Same columns as crisprs_all.tab
  * **crisprs_orphan.tab:**       Orphan CRISPRs (those not in CRISPR_Cas.tab)
      * Same columns as crisprs_all.tab
  * **crisprs_putative.tab:**     Low quality CRISPRs. Most likely false positives
      * Same columns as crisprs_all.tab
  * **cas_operons_orphan.tab:**   Orphan Cas operons (those not in CRISPR_Cas.tab)
      * Same columns as cas_operons.tab
  * **CRISPR_Cas_putative.tab:**  Putative CRISPR_Cas loci, often lonely Cas genes next to a CRISPR array
      * Same columns as CRISPR_Cas.tab
  * **cas_operons_putative.tab:** Putative Cas operons, mostly false positives, but also some ambiguous and partial systems
      * Same columns as cas_operons.tab
  * **spacers/*.fa:**             Fasta files with all spacer sequences
  * **hmmer.tab:**                All HMM vs. ORF matches, unfiltered results
      * Hmm: HMM name
      * ORF: ORF name (Sequence accession _ Gene ID)
      * tlen: ORF length
      * qlen: HMM length
      * Eval: E-value of alignment
      * score: Alignment score
      * start: ORF start
      * end: ORF end
      * Acc: Sequence accession
      * Pos: Gene ID
      * Cov_seq: Sequence coverage
      * Cov_hmm: HMM coverage
      * strand: Coding strand is like input (1) or reverse complement (-1)
  * **genes.tab**                 All genes and their positions
      * Contig: Sequence accession
      * Start: Start of ORF
      * End: End of ORF
      * Strand: Coding strand is like input (1) or reverse complement (-1)
      * Pos: Gene ID
  * **arguments.tab:**            File with arguments given to CRISPRCasTyper
  * **hmmer.log**                 Error messages from HMMER (only produced if any errors were encountered)


  * **prodigal.log**              Log from prodigal
  * **proteins.faa**              Protein sequences
  * **hmmer/*.tab**               Alignment output from HMMER for each Cas HMM
  * **minced.out:**               CRISPR array output from minced
  * **blast.tab:**                BLAST output from repeat alignment against flanking regions of cas operons
  * **Flank....:**                Fasta of flanking regions near cas operons and BLAST database of this


  Files are only created if there is any data. For example, the CRISPR_Cas.tab file is only created if there are any CRISPR-Cas loci.


  CRISPRCasTyper will automatically plot a map of the CRISPR-Cas loci, orphan Cas operons, and orphan CRISPR arrays.

  These maps can be expanded (`--expand N`) by adding unknown genes and genes with alignment scores below the thresholds. This can help in identify potentially un-annotated genes in operons. You can generate new plots without having to re-run the entire pipeline by adding `--redo_typing` to the command. This will re-use the mappings and re-type the operons and re-make the plot, based on new thresholds and plot parameters.

  The plot below is run with `--expand 5000`

  * Arrays are in alternating black/white displaying the actual number of repeats/spacers, and with their predicted subtype association based on the consensus repeat sequence.
  * The interference module is in yellow.
  * The adaptation module is in blue.
  * Cas6 is in red.
  * Accessory genes are in purple
  * Genes with alignment scores below the thresholds are lighter and with parentheses around names.
  * Unknown genes are in gray (the number matches the genes.tab file)

  <img src='img/plot2.svg' align="left" height="350" />


  With an input of CRISPR repeats (one per line, in a simple textfile) RepeatTyper will predict the subtype, based on the kmer composition of the repeat


  ```sh
  conda activate cctyper
  ```


  ```sh
  repeatType repeats.txt
  ```


  The script prints:
  * Repeat sequence
  * Predicted subtype
  * Probability of prediction


  * Predictions with probabilities below 0.75 are uncertain, and should be taken with a grain of salt.
  * Prior to version 1.4.0 the curated repeatTyper model was included in CCTyper
  * From version 1.4.0 and onwards updated repeatTyper models are included in CCTyper (see more information in the section below)
  * The followinig subtypes are included in the updated model as per December 2022:
      * I-A, I-B, I-C, I-D, I-E, I-F, I-F (Transposon), I-G
      * II-A, II-B, II-C
      * III-A, III-B, III-C, III-D, III-E, III-F
      * IV-A1, IV-A2, IV-A3, IV-D, IV-E
      * V-A, V-B1, V-E, V-F1, V-F2, V-F3, V-F (the rest), V-G, V-I, V-J, V-K
      * VI-A, VI-B1, VI-B2, VI-C, VI-D
  * This is the accuracy per subtype (on an unseen test dataset):
  * I-A      0.76
  * I-B      0.81
  * I-C      0.97
  * I-D      0.86
  * I-E      0.95
  * I-F      0.96
  * I-F_T    0.99
  * I-G      0.89
  * II-A     0.92
  * II-B     0.97
  * II-C     0.90
  * III-A    0.82
  * III-B    0.68
  * III-C    0.60
  * III-D    0.59
  * III-E    1.00
  * III-F    0.25
  * IV-A1    0.85
  * IV-A2    0.68
  * IV-A3    0.96
  * IV-D     0.85
  * IV-E     0.92
  * V-A      1.00
  * V-B1     0.90
  * V-E      0.30
  * V-F      0.87
  * V-F1     0.87
  * V-F2     0.90
  * V-F3     0.90
  * V-G      0.67
  * V-I      0.80
  * V-J      0.63
  * V-K      0.99
  * VI-A     0.96
  * VI-B1    0.96
  * VI-B2    1.00
  * VI-C     0.67
  * VI-D     0.97


  The [CCTyper webserver](https://typer.crispr.dk) is crowdsourcing subtyped repeats and includes an updated RepeatTyper model based on a much larger set of repeats and contains additional subtypes compared to the curated RepeatTyper model.
  This updated model is automatically retrained each month and the models can be downloaded [here](http://mibi.galaxy.bio.ku.dk/russel/repeattyper/).

  From version 1.4.0 and onwards of CCTyper the newest repeatTyper model is included upon release of the version.

  Each model contains a training report (xgb_report), where you can find the training log, and in the bottom the accuracy, both overall and per subtype.


  Save the original database files:
  ```sh
  mv ${CCTYPER_DB}/type_dict.tab ${CCTYPER_DB}/type_dict_orig.tab
  mv ${CCTYPER_DB}/xgb_repeats.model ${CCTYPER_DB}/xgb_repeats_orig.model
  ```

  Move the new model into the database folder
  ```sh
  mv repeat_model/* ${CCTYPER_DB}/
  ```




  You can train the repeat classifier with your own set of subtyped repeats. With a tab-delimeted input where 1. column contains the subtypes and 2. column contains the CRISPR repeat sequences, RepeatTrain will train a CRISPR repeat classifier that is directly usable for both RepeatTyper and CRISPRCasTyper.


  ```sh
  repeatTrain typed_repeats.tab my_classifier
  ```


  ```sh
  repeatType repeats.txt --db my_classifier
  ```


  Save the original database files:
  ```sh
  mv ${CCTYPER_DB}/type_dict.tab ${CCTYPER_DB}/type_dict_orig.tab
  mv ${CCTYPER_DB}/xgb_repeats.model ${CCTYPER_DB}/xgb_repeats_orig.model
  ```

  Move the new model into the database folder
  ```sh
  mv my_classifier/* ${CCTYPER_DB}/
  ```






  Large metagenomic assemblies with many small contigs can exhaust the RAM on your laptop. Fortunately, as metagenomic contigs are analysed separately (when run with `--prodigal meta`) a simple solution is to split the input into smaller chunks (e.g. with [pyfasta](https://pypi.org/project/pyfasta/#command-line-interface))


pkgId: 18eca1d63a8e2d6a1d388f9d92d57244974fbc2f4e54bb2d82ed60c12ef02764
name: python-ccxtools
arch: src
version: 0.0.128
epoch: 0
release: 1
summary: ccxtools
url: https://github.com/WoosubLeee/ccxtools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccxtools-0.0.128-1.src.rpm
checksum_type: sha256
description:
  CryptoCurrency eXchange TOOLS

  암호화폐 자동매매 관련 라이브러리인 CCXT를 기반으로 만들어진 암호화폐 자동매매용 Python 3 라이브러리입니다.



  [ccxtools in PyPI](https://pypi.org/project/ccxtools/)

  ```
  pip install ccxtools
  ```



  ccxtools는 ccxt에서 함수로 구현되지 않은 API와 저 개인적으로 매매 프로그램을 개발할 때 필요한 함수들을 구현한 라이브러리이기 때문에 암호화폐 매매에 필요한 모든 API를 담고있지는 않습니다. 기본적인 API는 [ccxt](https://github.com/ccxt/ccxt)를 참조하시기 바랍니다.

  - 거래소별로 다른 ticker 형식을 일일이 작성할 필요없이 코인 이름만으로 사용할 수 있습니다.

    ```python
    {ticker}USDT, {ticker}-USDT, {ticker}/USDT
    => {ticker}만 입력하면 됩니다.
    ```

  - ccxt에서 함수로 구현해놓지 않은 API를 함수로 구현해 놓았습니다.

    - Bybit
      - max_trading_qty
      - risk_limit 관련

  - pytest로 테스트를 구현해놓아 API나 CCXT 내용 변경에 신속히 대응할 수 있습니다.


pkgId: 707387582051138cf323c05e98b00486b428fb8438536584ba1a60ffef6969b5
name: python-ccxw
arch: src
version: 0.2.11
epoch: 0
release: 1
summary: Ccxw - CryptoCurrency eXchange Websocket Library
url: https://github.com/rmalvarezkai/ccxw
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccxw-0.2.11-1.src.rpm
checksum_type: sha256
description:
  This library is designed to fetch data from exchange WebSocket APIs and store or update data in a temporary SQLite database in the background, making it readily accessible for retrieval.

  Currently, it is available for several exchanges, including Binance, Bybit, and more. You can find a complete list of supported exchanges using `Ccxw.get_supported_exchanges()`.

  Furthermore, the library supports a variety of endpoints, such as order_book, kline, and more. A comprehensive list of supported endpoints can be found via `Ccxw.get_supported_endpoints()`.




  ```bash
  pip install ccxw
  ```


  ```python
  import time
  import pprint
  from ccxw import Ccxw

  symbol = 'BTC/USDT'

  streams = [\
                  {\
                      'endpoint': 'order_book',\
                      'symbol': symbol
                  },\
                  {\
                      'endpoint': 'kline',\
                      'symbol': symbol,\
                      'interval': interval\
                  },\
                  {\
                      'endpoint': 'trades',\
                      'symbol': symbol
                  },\
                  {\
                      'endpoint': 'ticker',\
                      'symbol': symbol
                  }\
          ]

  wsm = Ccxw('binance',\
              streams,\
              result_max_len=5,\
              data_max_len=10)

  wsm.start()  # Start getting data

  time.sleep(2)  # Wait for available data

  for i in range(0, 10):
      for stream in streams:
          interval = 'none'
          if 'interval' in stream:
              interval = stream['interval']
          data = wsm.get_current_data(stream['endpoint'], stream['symbol'], interval)
          pprint.pprint(data, sort_dicts=False)
          print('----------------------------------')
          time.sleep(1)
      print('============================================================')

  wsm.stop()  # Stop getting data
  ```



  Please be aware that each instance opens a new connection to websockets. If you create multiple instances for the same exchange, you may exceed the websockets connection limits set by exchanges. Make sure to check the connection limits of exchanges before opening numerous instances.

  [View License](LICENSE)


pkgId: 2909e26e201ad0ed65ee60858bd8315673aee0ab176e124da61091859e69ea98
name: python-ccy
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Python currencies
url: https://pypi.org/project/ccy/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ccy-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ccy.svg)](https://badge.fury.io/py/ccy)
  [![Python versions](https://img.shields.io/pypi/pyversions/ccy.svg)](https://pypi.org/project/ccy)
  [![Python downloads](https://img.shields.io/pypi/dd/ccy.svg)](https://pypi.org/project/ccy)
  [![build](https://github.com/quantmind/ccy/actions/workflows/build.yml/badge.svg)](https://github.com/quantmind/ccy/actions/workflows/build.yml)
  [![codecov](https://codecov.io/gh/quantmind/ccy/branch/main/graph/badge.svg?token=2L5SY0WkXv)](https://codecov.io/gh/quantmind/ccy)

  A python module for currencies. The module compiles a dictionary of
  currency objects containing information useful in financial analysis.
  Not all currencies in the world are supported yet. You are welcome to
  join and add more.

  * Documentation is available as [ccy jupyter book](https://quantmind.github.io/ccy/).
  * Install the command line tool with `pip install ccy[cli]`.
  * Show all currencies in the command line via `ccys show`


pkgId: 963d13102e5549701b961e5ec15951404e344d181b92afbc42a82b893eaa5cfd
name: python-cdascorer
arch: src
version: 0.0.0.dev26
epoch: 0
release: 1
summary: Cell Death Area Data Collection
url: https://github.com/joshuandwilliams/CDAScorer
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdascorer-0.0.0.dev26-1.src.rpm
checksum_type: sha256
description:
  Home of Python package CDAScorer

  For a guide on how to use this package, please visit the [tutorial page](https://joshuandwilliams.github.io/CDAScorer/tutorial/).


pkgId: 2ceb4745b2f77c1de8d42b82b618e953d46b29273ae769faf7ffd28abb59040c
name: python-cdasws
arch: src
version: 1.8.5
epoch: 0
release: 1
summary: NASA's Coordinated Data Analysis System Web Service Client Library
url: https://cdaweb.gsfc.nasa.gov/WebServices/REST
rpm_license: NOSA
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdasws-1.8.5-1.src.rpm
checksum_type: sha256
description:
  Also, the following [Jupyter notebooks](https://jupyter.org/) demonstrate
  different features of the library:
  1. [Basic Example](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsExample.html) ([ipynb file](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsExample.ipynb)) demonstrating use of library with results returned in [SpacePy data model](https://spacepy.github.io/datamodel.html). [Launch on Binder](https://mybinder.org/v2/gh/berniegsfc/cdasws-notebooks/main?labpath=CdasWsExample.ipynb).
  2. [Basic Example](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsExampleXarray.html) ([ipynb file](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsExampleXarray.ipynb)) demonstrating use of library with results returned in an [xarray.Dataset](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html). [Launch on Binder](https://mybinder.org/v2/gh/berniegsfc/cdasws-notebooks/main?labpath=CdasWsExampleXarray.ipynb).


pkgId: 14b5860966886b76b8dbfa9bd5cb524cf888bb3a8893ea335b6e00921d0ba001
name: python-cdasws
arch: src
version: 1.8.8
epoch: 0
release: 1
summary: NASA's Coordinated Data Analysis System Web Service Client Library
url: https://cdaweb.gsfc.nasa.gov/WebServices/REST
rpm_license: NOSA
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdasws-1.8.8-1.src.rpm
checksum_type: sha256
description:
  Also, the following [Jupyter notebooks](https://jupyter.org/) demonstrate
  different features of the library:
  1. [Data Retrieval](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsDataRetrieval.html) ([ipynb file](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsDataRetrieval.ipynb)) demonstrating use of library with results returned in [SpacePy data model](https://spacepy.github.io/datamodel.html), [xarray.Dataset](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html), and [pandas.DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html). [Launch on Binder](https://binder.opensci.2i2c.cloud/v2/gh/berniegsfc/cdasws-notebooks/main?labpath=CdasWsDataRetrieval.ipynb).
  2. [CDAWeb Binning Example](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsBinningExample.html) ([ipynb file](https://cdaweb.gsfc.nasa.gov/WebServices/REST/jupyter/CdasWsBinningExample.ipynb)) demonstrating use [CDAWeb binning](https://cdaweb.gsfc.nasa.gov/CDAWeb_Binning_readme.html). [Launch on Binder](https://binder.opensci.2i2c.cloud/v2/gh/berniegsfc/cdasws-notebooks/main?labpath=CdasWsBinningExample.ipynb).


pkgId: 30a646fb14c295ccff8594ef63b0ad849a255599d1471fc8b9812647dadc079a
name: python-cdcs
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Python API client for performing REST calls to configurable data curation system (CDCS) databases
url: https://github.com/usnistgov/pycdcs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdcs-0.2.3-1.src.rpm
checksum_type: sha256
description:
  This is a base Python package for accessing instances of the NIST Configurable Data Curation System (CDCS) databases, versions 2.X.X and 3.X.X.  It defines a Python CDCS class that streamlines REST calls to a database by

  - Taking access settings once (username, password, etc) and saving them for subsequent REST calls.
  - Defining methods that wrap around REST calls to interact with the database in a more Pythonic way.
  - Automatically converting any accessed information to pandas Series and DataFrame objects to allow for the information to be easily manipulated.



  The package can be installed using pip:

      pip install cdcs

  or conda:

      conda install -c conda-forge cdcs

  Alternatively, the source code can be downloaded from github at

  - Stable releases: [https://github.com/usnistgov/pycdcs](https://github.com/usnistgov/pycdcs)
  - In development: [https://github.com/lmhale99/pycdcs](https://github.com/lmhale99/pycdcs)



  Documentation for the package is given as Jupyter Notebooks that can be found on the github site.  Each Notebook is focused on providing details and examples related to different use cases for the package.

  - **CDCS Public Data Exploration** outlines the basic functions allowing an anonymous user (i.e. not logged in) to explore the available public data on a curator.
  - **CDCS Data Management** outlines the basic pre-defined functions allowing a logged-in user to manage their own templates, data records and blobs.
  - **CDCS Rest Builder** provides a simple explanation of how users can easily build their own functions and make their own REST API calls should they wish to interact with the database in ways outside the pre-defined functions.


pkgId: 10e01d879f3687155c796d1fc47ce7e5bb9fc0f9430740d4cec11a5808e07ad4
name: python-cde
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Framework for conditional density estimation
url: https://jonasrothfuss.github.io/Nonparametric_Density_Estimation
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cde-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/freelunchtheorem/Conditional_Density_Estimation.svg?branch=master)](https://travis-ci.org/freelunchtheorem/Conditional_Density_Estimation) [![Downloads](https://pepy.tech/badge/cde)](https://pepy.tech/project/cde)




  Implementations of various methods for conditional density estimation

  * **Parametric neural network based methods**
      * Mixture Density Network (MDN)
      * Kernel Mixture Network (KMN)
      * Normalizing Flows (NF)
  * **Nonparametric methods**
      * Conditional Kernel Density Estimation (CKDE)
      * Neighborhood Kernel Density Estimation (NKDE)
  * **Semiparametric methods**
      * Least Squares Conditional Density Estimation (LSKDE)

  Beyond estimating conditional probability densities, the package features extensive functionality for computing:
  * **Centered moments:** mean, covariance, skewness and kurtosis
  * **Statistical divergences:** KL-divergence, JS-divergence, Hellinger distance
  * **Percentiles and expected shortfall**



  To use the library, you can directly use the python package index:
  ```bash
  pip install cde
  ```
  or clone the GitHub repository and run
  ```bash
  pip install .
  ```
  Note that the package only supports tensorflow versions between 1.4 and 1.7.

  See the documentation [here](https://freelunchtheorem.github.io/Conditional_Density_Estimation). A paper on best practices and benchmarks on conditional density estimation with neural networks that makes extensive use of this library can be found [here](https://arxiv.org/abs/1903.00954).


  The following code snipped holds an easy example that demonstrates how to use the cde package.
  ```python
  from cde.density_simulation import SkewNormal
  from cde.density_estimator import KernelMixtureNetwork
  import numpy as np

  """ simulate some data """
  density_simulator = SkewNormal(random_seed=22)
  X, Y = density_simulator.simulate(n_samples=3000)

  """ fit density model """
  model = KernelMixtureNetwork("KDE_demo", ndim_x=1, ndim_y=1, n_centers=50,
                               x_noise_std=0.2, y_noise_std=0.1, random_seed=22)
  model.fit(X, Y)

  """ query the conditional pdf and cdf """
  x_cond = np.zeros((1, 1))
  y_query = np.ones((1, 1)) * 0.1
  prob = model.pdf(x_cond, y_query)
  cum_prob = model.cdf(x_cond, y_query)

  """ compute conditional moments & VaR  """
  mean = model.mean_(x_cond)[0][0]
  std = model.std_(x_cond)[0][0]
  skewness = model.skewness(x_cond)[0]
  ```

  If you use CDE in your research, you can cite it as follows:

  ```
  @article{rothfuss2019conditional,
    title={Conditional Density Estimation with Neural Networks: Best Practices and Benchmarks},
    author={Rothfuss, Jonas and Ferreira, Fabio and Walther, Simon and Ulrich, Maxim},
    journal={arXiv:1903.00954},
    year={2019}
  }

  ```


  - creating a branch just for our conditional estimators + python package


pkgId: eda667e3feee195f3e97c3ca7a5e86fd2a80c8245ac861007ec0331469e13c07
name: python-cdev
arch: src
version: 0.0.31
epoch: 0
release: 1
summary: CLI for cdev sdk
url: https://pypi.org/project/cdev/
rpm_license: Clear BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdev-0.0.31-1.src.rpm
checksum_type: sha256
description:
  Cdev provides a development environment and framework that allows python developers to easily create and deploy Serverless Applications on Amazon Web Services. By providing features like automated dependency management, isolated deployment environments, and function artifact optimizations, Cdev allows developers to focus on the development of their project then deploy an optimized version of their project onto Aws with a single command.

  [![](https://cdevframework.io/images/github_banner.png)](https://cdevframework.io)


  [Website](https://cdevframework.io/) • [Docs](https://cdevframework.io/docs/)



  - [An Aws account and credentials](https://aws.amazon.com/)
  - [Requires Python>=3.6 and pip](https://cdevframework.io/docs/gettingstarted/python/)
  - it is **highly** encouraged to use a python virtual environment

  Starting from an empty directory. Set up your python virtual environment and install the Cdev cli.
  ```
  $ python -m venv .venv

  $ . ./.venv/bin/activate

  $ pip install cdev

  $ cdev
  ```


  When creating a new project, you will be prompted about your Aws credentials and to link to a `S3 Bucket` for your deployment artifacts to be stored in.
  ```
  $ cdev init demo-project --template quick-start
  **Aws Credentials and S3 Bucket Selection Wizard**
  ```


  ```
  $ cdev plan
  ```


  ```
  $ cdev deploy
  ```


  ```
  $ cdev run function.execute hello_world_comp.hello_world_function
  ```


  You might have to wait a few seconds for the logs to process in the cloud
  ```
  $ cdev run function.logs hello_world_comp.hello_world_function
  ```


  Invoke the deployed function via the created HTTP Api
  ```
  $ cdev output hello_world_comp.api.demoapi.endpoint
  <url>
  ```

  ```
  $ curl <url>/hello_world
  ```

  You can also visit `<url>/hello_world` in your favorite web browser!



  ```
  $ cdev destroy
  ```

  For a more in depth information and examples about the capabilities of Cdev, check out our [documentation](https://cdevframework.io/docs/).



  - [Serverless Function Parsing](https://cdevframework.io/docs/firstprinciples/serverless_optimizations/#serverless-function-parsing)
  - [Automated and Optimized Dependency Management](https://cdevframework.io/docs/firstprinciples/serverless_optimizations/#automated-dependency-management)
  - [Light-weight isolated environments](https://cdevframework.io/docs/firstprinciples/project_management/#environments)



  - Serverless Function
  - HTTP Endpoint
  - S3 Bucket
  - Dynamodb
  - Aurora DB (Mysql and Postgres)
  - Sqs
  - Sns
  - Hosted Static Website (Aws Cloudfront)

  For guides on how to deploy any of these resources, check out our [documentation](https://cdevframework.io/docs/resources)



  The project is still in an `alpha` state, so there are still rough edges and limitations. The following are the current high level limitations of the framework.

  - Recovery from Failed Deployments
      - Certain resources require multiple API calls to generate the proper configurations in the Cloud, and if one of the API calls fails, it can cause the Cloud resource to be in a state that needs to be manually updated before continuing the deployment.

  - Parallel Deployments
      - Non-dependant resources can be deployed in parallel to reduce the total deployment time when there are many changes in a single deployment.

  - Remote Backend
      - The current state of cloud resources are stored in json files. This is extremely limiting as it prevents multiple people from working on the same state at the same time.

  - Limited Resources and Options on Resources
      - We are starting by focusing on a set of resource that we feel provide value while not being too complex. We have plans to add more resource and customization as time goes on.

  - Codebase improvements
      - Improvements in unit test coverage, logging, and error handling/messaging.

  All of the current limitations can be navigated to use Cdev effectively for projects and solutions are being worked on to over come the documented limitations. Any issues that arise while using Cdev can be raised to daniel@cdevframework.com and will be addressed.


pkgId: f8126064321178de47afaa7ce82be0b2956062ceef7dc90eb545151cc7500a04
name: python-cdflib
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A python CDF reader toolkit
url: https://github.com/MAVENSDC/cdflib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdflib-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Run tests](https://github.com/MAVENSDC/cdflib/actions/workflows/ci.yml/badge.svg)](https://github.com/MAVENSDC/cdflib/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/MAVENSDC/cdflib/branch/master/graph/badge.svg?token=IJ6moGc40e)](https://codecov.io/gh/MAVENSDC/cdflib)
  [![DOI](https://zenodo.org/badge/102912691.svg)](https://zenodo.org/badge/latestdoi/102912691)
  [![Documentation Status](https://readthedocs.org/projects/cdflib/badge/?version=latest)](https://cdflib.readthedocs.io/en/latest/?badge=latest)



  `cdflib` is a python module to read/write CDF (Common Data Format `.cdf`) files without needing to install the
  [CDF NASA library](https://cdf.gsfc.nasa.gov/).

  Python >= 3.8 is required.
  The core of this package uses only numpy, with no complicated compiler requirements.



  To install, open up your terminal/command prompt, and type:
  ```sh
  pip install cdflib
  ```



  The full documentation can be found here:

  [https://cdflib.readthedocs.io/en/latest/](https://cdflib.readthedocs.io/en/latest/)


pkgId: fe72327150f255efee11458f2d8a3d241504f0ac14bbbd8aadf834b13f7c1267
name: python-cdfwriter
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: A small and simple package for writing CDF files
url: https://github.com/joeymukherjee/cdfwriter
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdfwriter-1.0.10-1.src.rpm
checksum_type: sha256
description:
  This is a Python package developed at Southwest Research Institute
  that aims to provide a simple and efficient solution to generating CDF files.

  It uses a high level Object-Oriented interface method that allows for
  the definition of a common set of CDF files that are similar.

  The cdfwriter package uses spacepy.pycdf to write a common set of CDFs
  and makes use of the numpy package.


pkgId: 83ea8fc952f9d3e4d853622544f06223e9c035921b45c66464a98c53533a24c2
name: python-cdhist
arch: src
version: 4.0
epoch: 0
release: 1
summary: Program to provide a Linux cd history directory stack
url: https://github.com/bulletmark/cdhist
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdhist-4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/cdhist)](https://pypi.org/project/cdhist/)
  [![AUR](https://img.shields.io/aur/version/cdhist)](https://aur.archlinux.org/packages/cdhist/)

  [cdhist](http://github.com/bulletmark/cdhist) is a utility which
  provides a Linux shell **cd history** directory stack. A shell `cd`
  wrapper function calls cdhist to intercept your typed `cd` command and
  maintain an ordered stack of all directories you have previously visited
  which can be listed and quickly navigated to.

  [cdhist](http://github.com/bulletmark/cdhist) can also be used with the
  [Command Line Fuzzy Finder](https://github.com/junegunn/fzf) `fzf` to
  fuzzy search and select on previously visited directories, and can be
  used to easily `cd` between [`git worktree`](https://git-scm.com/docs/git-worktree)
  directories. See the sections below about [FZF
  Integration](#fzf-integration) and [Git Worktree
  Integration](#git-worktree-integration).

  The latest version and documentation is available at
  http://github.com/bulletmark/cdhist.



  Use the `cd` command to change directory as normal:

  ```sh
  $ cd /tmp
  $ cd /etc
  $ cd /usr/share/doc
  $ cd /boot/loader
  $ cd ~/etc
  $ cd
  ```

  At any point you can use the `cd --` command to list all your previously
  visited directories and be prompted for one to select and `cd` to:

  ```
  $ cd --
    6 ...
    5 /tmp
    4 /etc
    3 /usr/share/doc
    2 /boot/loader
    1 ~/etc
    0 ~
  Select index [or <enter> to quit]: 3
  $ pwd
  /usr/share/doc
  ```

  That's it! The above is all you really need to know. Instead of having
  to type the directory name you merely enter it's index. The directories
  are displayed most recently visited last, without duplicates. Index 0 is
  the current directory, index 1 is the previous, index 2 is the second
  previous, up to a user configurable number (default 50). Other available
  commands and options are:

  List the current stack and its indices (without prompting):

  ```sh
  $ cd -l
  ```

  Change immediately to directory corresponding to stack index 4:

  ```sh
  $ cd -4
  ```

  Search back through stack for directory containing "string" and `cd`
  there:

  ```sh
  $ cd -/string
  ```

  Note, you can also type `string` at the `cd --` prompt to search.

  Show help/usage:

  ```sh
  $ cd -h
  ```



  Arch users can install [cdhist from the
  AUR](https://aur.archlinux.org/packages/cdhist/) and skip to the next
  section.

  Python 3.8 or later is required. Note [cdhist is on
  PyPI](https://pypi.org/project/cdhist/) so just ensure that
  [`pipx`](https://pypa.github.io/pipx/) is installed then type the
  following:

  ```
  $ pipx install cdhist
  ```

  To upgrade:

  ```
  $ pipx upgrade cdhist
  ```



  A user who wants to use the cdhist facility should add the following
  lines to their `~/.bashrc` or `~/.zshrc` file (after where your PATH is
  set up so that the command `cdhist` can be found). This creates the `cd`
  wrapper command in your interactive shell session as a tiny function.
  Note you can [customize the command name](#alternative-command-name) if
  you want.

  ```sh
  if type cdhist &>/dev/null; then
      . <(cdhist -i)
  fi
  ```

  Then log out and back in again.



  The popular [Command Line Fuzzy Finder](https://github.com/junegunn/fzf)
  `fzf` can easily be integrated with cdhist to provide fuzzy search
  navigation over your directory history. Set the following in your
  environment to have `fzf` search the directories recorded by cdhist:

  ```sh
  export FZF_ALT_C_COMMAND="cat $HOME/.cd_history"
  ```

  You also should make a small change to the way you source the `fzf`
  key-bindings and completions into your shell to ensure that the `cd`
  command is not aliased to `builtin cd` and instead invokes the `cdhist`
  command.

  E.g. for `bash`, in your `~/.bashrc`, instead of `eval "$(fzf --bash)"`
  as suggested by the [`fzf` documentation](
  https://github.com/junegunn/fzf?tab=readme-ov-file#setting-up-shell-integration),
  use:

  ```sh
  eval "$(fzf --bash | sed 's/builtin cd/cd/g')"
  ```

  E.g. for `zsh`, in your `~/.zshrc`, instead of `source <(fzf --zsh)`
  as suggested by the [`fzf` documentation](
  https://github.com/junegunn/fzf?tab=readme-ov-file#setting-up-shell-integration),
  use:

  ```sh
  source <(fzf --zsh | sed 's/builtin cd/cd/g')
  ```

  After doing this (and reloading your shell session), you can use the
  `fzf` key binding `<ALT+C>` to have `fzf` list all your previous
  directories and fuzzy match on them for selection as you type. `fzf` can
  also provide fancy [directory
  previews](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings#preview-1)
  using `tree`, etc. Of course the cdhist native command `cd --` and
  other cdhist commands described above are still available, in addition
  to the `fzf` key binding.


  If you prefer that directories that do not exist are excluded from `fzf`
  and your `cd` history (i.e. exclude directories that have been deleted
  since they were last visited), then you can define the `fzf` command as:

  ```sh
  export FZF_ALT_C_COMMAND="cdhist -p && cat $HOME/.cd_history"
  ```

  An alternative is to always exclude non-existent directories from your
  cd history by setting the `--prune-always` as a [default
  option](#default-options).



  Some people may prefer not to alias their system `cd` command to this
  utility and just use an alternative unique command name. To do this,
  simply add your desired command name as an extra argument to the
  `cdhist` command in your shell initialization code. E.g, to use the
  command name `xd` rather than `cd`, use the following in
  your `~/.bashrc` or `~/.zshrc` file:

  ```sh
  if type cdhist &>/dev/null; then
      . <(cdhist -i xd)
  fi
  ```

  Then log out/in, and then just type `xd /tmp` to change dir, `xd --` to see
  and select directories, etc.



  [cdhist](http://github.com/bulletmark/cdhist) can be used to easily `cd`
  between [git worktree](https://git-scm.com/docs/git-worktree)
  directories. You use the `cd -g` command to list all your worktrees and
  be prompted for one to select, and then you will be switched to the
  associated directory, and it will be added to your `cd` history.

  ```sh

  $ pwd
  /home/mark/src/myprog


  $ git worktree list
  /home/mark/src/myprog       f76b8e0 [main]
  /home/mark/src/development  9796714 [development]
  /home/mark/src/milestone1   bc921b8 [milestone1]
  /home/mark/src/test         e6d965a [test]


  $ cd -g
    3 ~/src/development 9796714 [development]
    2 ~/src/milestone1  bc921b8 [milestone1]
    1 ~/src/test        e6d965a [test]
    0 ~/src/myprog      f76b8e0 [main]
  Select index [or <enter> to quit]: 2

  $ pwd
  /home/mark/src/milestone1



  $ cd -g main
  $ pwd
  /home/mark/src/myprog

  ```

  Instead of having to type the full git repository directory name you
  merely are prompted with a list and enter it's index. Or just directly
  enter the branch name (or commit hash). The directories are displayed in
  the same order as the output of the `git worktree list` command, except
  that the git directory corresponding to the current working directory is
  shown first (index 0) consistent with how the current directory is shown
  at index 0 for normal cd history and thus conveniently showing you which
  git worktree you are currently in which `git worktree list`
  unfortunately does not show.

  In you enter text instead of an index, you only need to enter as much of
  the branch name, or commit hash, as needed to be unique. Note that `cd
  -g` nicely presents paths based from your HOME directory with a tilde
  (`~`) unlike the longer full path displayed by `git worktree list`
  (although you can change that with the `-u/--no-user` option, likely set
  as a [default option](#default-options)).



  The `git worktree list` command displays absolute directory paths, and
  cdhist does also by default, but many users prefer them displayed
  as relative paths. The Git worktree command does not provide this but
  you can enable it in cdhist by adding the `-r/--relative` option, e.g:

  ```sh
  $ cd -gr
    3 ../development 9796714 [development]
    2 ../milestone1  bc921b8 [milestone1]
    1 ../test        e6d965a [test]
    0 .              f76b8e0 [main]
  Select index [or <enter> to quit]:
  ```

  Most likely you will want to set this as your default so do that by
  adding `--relative` as a [default option](#default-options).



  Some users may want the git worktree functionality provided by cdhist
  but are not interested in the standard `cd` history functionality, or
  alternately, want to use a completely separate command for the git
  worktree functionality. To do this, simply add your desired command name
  and the git option as an extra argument to the `cdhist` command in your
  shell initialization code. E.g, to use the command name `wt` for git
  worktree functionality (only), add the following in your
  `~/.bashrc` or `~/.zshrc` file:

  ```sh
  if type cdhist &>/dev/null; then
      . <(cdhist -i "wt -g")
  fi
  ```

  Then log out/in, and then just type `wt` to list the git worktrees and
  be prompted to select the directory etc. Of course, you can define this
  `wt` command in parallel to using cdhist for your `cd` command if
  you want.



  You can set default cdhist options by adding options in your shell
  initialization code, e.g:

  ```sh
  if type cdhist &>/dev/null; then
      . <(cdhist -i "cd -arm 200")
  fi
  ```

  The above sets `-a (--purge-always)`, `-r (--git-relative)`, and `-m
  (--size) 200` options as defaults for your `cd` command. Best to use the
  short option names to keep the imported shell function definition
  concise.

  Note you can create one alias for your `cd` command, and another alias
  for your git worktree command (e.g. `wt`), and both can have different
  cdhist options.

  The following options are sensible candidates to set as default options:
  `-a/--purge-always`, `-r/--git-relative`, `-u/--no-user`, `-m/--size`.

  Note if you set `-r/--git-relative` or `-u/--no-user` options as default
  then options `-R/--no-git-relative` and `-U/--user` exist to allow you
  to temporarily override those defaults via the command line.



  Type `cdhist -h` to view the usage summary:

  ```
  usage: cdhist [-i] [-h] [-p] [-a] [-g] [-r] [-R] [-u] [-U] [-l] [-m SIZE]
                     [-n NUM_LINES] [-L] [-P] [-V]
                     [directory]

  A Linux shell directory stack "cd history" function.

  positional arguments:
    directory             directory (or branch for git worktree) to cd to, or
                          "--" to list history and prompt, or "-n" for n'th
                          entry in list or "-/<string>" to match for "string" in
                          dir

  options:
    -i, --init            output shell initialization code. Optionally specify
                          alternative command name as argument, default="cd"
    -h, --help            show help/usage
    -p, --purge           just purge non-existent directories from history
    -a, --purge-always    always purge non-existent directories every write
    -g, --git             show git worktree directories instead
    -r, --git-relative    show relative git worktree paths instead of absolute
    -R, --no-git-relative
                          do not show relative git worktree paths (default)
    -u, --no-user         do not substitute "~" for home directory
    -U, --user            do substitute "~" for home directory (default)
    -l, --list            just list directory history
    -m SIZE, --size SIZE  maximum size of directory history (default=50)
    -n NUM_LINES, --num-lines NUM_LINES
                          limit output to specified number of lines
    -L, --follow-links    follow symbolic links (default=true)
    -P, --follow-physical
                          follow links to physical directory
    -V, --version         just output cdhist version
  ```



  Regular `cd`, e.g. as provided by the bash builtin, offers some esoteric
  command line options such as `-e` and `-@`, and shell options such as
  `autocd`, `cdspell`, `cdable_vars`. These rarely used options are not
  supported by cdhist.



  Copyright (C) 2010 Mark Blakeney. This program is distributed under the
  terms of the GNU General Public License.
  This program is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or any later
  version.
  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
  Public License at <http://www.gnu.org/licenses/> for more details.


pkgId: 93ba46d6d995c8f0b7c1cccf9733930146e42c03ffbad287beb71d732de899ca
name: python-cdiff
arch: src
version: 1.0
epoch: 0
release: 1
url: https://github.com/ymattw/cdiff
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdiff-1.0-1.src.rpm
checksum_type: sha256
summary:
  View colored, incremental diff in a workspace or from stdin, with side by side and auto pager support

description:
  Term based tool to view *colored*, *incremental* diff in a *Git/Mercurial/Svn*
  workspace or from stdin, with *side by side* and *auto pager* support. Requires
  python (>= 2.5.0) and ``less``.


pkgId: f7724625ef3e7548c7f5921d36631bf67549b2f63fd2a4f9ff6aed3212bca565
name: python-cdiffer
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Edit distance, Similarity and 2 sequence differences printing
url: https://github.com/kirin123kirin/cdiffer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdiffer-0.7.2-1.src.rpm
checksum_type: sha256
description:
  [![Upload pypi.org](https://github.com/kirin123kirin/cdiffer/actions/workflows/pypi.yml/badge.svg?branch=v0.7.2)](https://github.com/kirin123kirin/cdiffer/actions/workflows/pypi.yml)

  **Edit distance, Similarity and 2 sequence differences printing.**


  ```shell
  pip install cdiffer
  ```


  * python3.6 or later
  <!-- * python2.7 -->


  Compute absolute Levenshtein distance of two strings.


  dist(sequence, sequence)



  ```python
  Help on built-in function dist in module cdiffer:

  dist(...)
      Compute absolute Levenshtein distance of two strings.

      dist(sequence, sequence)

      Examples (it's hard to spell Levenshtein correctly):

      >>> dist('coffee', 'cafe')
      4
      >>> dist(list('coffee'), list('cafe'))
      4
      >>> dist(tuple('coffee'), tuple('cafe'))
      4
      >>> dist(iter('coffee'), iter('cafe'))
      4
      >>> dist(range(4), range(5))
      1
      >>> dist('coffee', 'xxxxxx')
      12
      >>> dist('coffee', 'coffee')
      0
  ```



  Compute similarity of two strings.


  similar(sequence, sequence)

  The similarity is a number between 0 and 1,
  base on levenshtein edit distance.


  ```python
  >>> from cdiffer import similar
  >>>
  >>> similar('coffee', 'cafe')
  0.6
  >>> similar('hoge', 'bar')
  0.0

  ```



  Find sequence of edit operations transforming one string to another.


  differ(source_sequence, destination_sequence, diffonly=False, rep_rate=60)



  ```python
  >>> from cdiffer import differ
  >>>
      >>> for x in differ('coffee', 'cafe'):
      ...     print(x)
      ...
      ['equal',   0, 0,   'c', 'c']
      ['delete',  1, None,'o',None]
      ['insert',  None, 1,None,'a']
      ['equal',   2, 2,   'f', 'f']
      ['delete',  3, None,'f',None]
      ['delete',  4, None,'e',None]
      ['equal',   5, 3,   'e', 'e']
      >>> for x in differ('coffee', 'cafe', diffonly=True):
      ...     print(x)
      ...
      ['delete',  1, None,'o',None]
      ['insert',  None, 1,None,'a']
      ['delete',  3, None,'f',None]
      ['delete',  4, None,'e',None]

      >>> for x in differ('coffee', 'cafe', rep_rate = 0):
      ...     print(x)
      ...
      ['equal',   0, 0,   'c', 'c']
      ['replace', 1, 1,   'o', 'a']
      ['equal',   2, 2,   'f', 'f']
      ['delete',  3, None,'f',None]
      ['delete',  4, None,'e',None]
      ['equal',   5, 3,   'e', 'e']
      >>> for x in differ('coffee', 'cafe', diffonly=True, rep_rate = 0):
      ...     print(x)
      ...
      ['replace', 1, 1,   'o', 'a']
      ['delete',  3, None,'f',None]
      ['delete',  4, None,'e',None]

  ```


  This Function is compare and prety printing 2 sequence data.


  compare(source_sequence, destination_sequence, diffonly=False, rep_rate=60, condition_value=" ---> ")


      arg1 -> iterable : left comare target data.
      arg2 -> iterable : right comare target data.
      keya -> callable one argument function : Using sort and compare with key about `a` object.
      keyb -> callable one argument function : Using sort and compare with key about `a` object.
      header -> bool : output data with header(True) or without header(False). <default True>
      diffonly -> bool : output data with equal data(False) or without equal data(True). <default False>
      rep_rate -> int: Threshold to be considered as replacement.(-1 ~ 100). -1: allways replacement.
      startidx -> int: output record index starting number. <default `0`>
      condition_value -> str : Conjunctions for comparison.
      na_value -> str: if not found data when filled value.
      delete_sign_value -> str: if deleted data when adding sign value.
      insert_sign_value ->  str: if insert data when adding sign value.


      1st column -> matching rate (0 ~ 100).
      2nd column -> matching tagname (unicode string).
      3rd over   -> compare data.



  ```python
  In [1]: from cdiffer import compare
  ... compare('coffee', 'cafe')
  [['tag', 'index_a', 'index_b', 'data'],
   ['equal', 0, 0, 'c'],
   ['insert', '-', 1, 'ADD ---> a'],
   ['delete', 1, '-', 'o ---> DEL'],
   ['equal', 2, 2, 'f'],
   ['delete', 3, '-', 'f ---> DEL'],
   ['equal', 4, 3, 'e'],
   ['delete', 5, '-', 'e ---> DEL']]

  In [2]: compare([list("abc"), list("abc")], [list("abc"), list("acc"), list("xtz")], rep_rate=50)
  [['tag', 'index_a', 'index_b', 'COL_00', 'COL_01', 'COL_02', 'COL_03'],
   ['equal', 0, 0, 'a', 'b', 'c'],
   ['replace', 1, 1, 'a', 'b ---> DEL', 'ADD ---> c', 'c'],
   ['insert', '-', 2, 'ADD ---> x', 'ADD ---> t', 'ADD ---> z']]

  In [3]: compare(["abc", "abc"], ["abc", "acc", "xtz"], rep_rate=40)
  [['tag', 'index_a', 'index_b', 'data'],
   ['equal', 0, 0, 'abc'],
   ['replace', 1, 1, 'abc ---> acc'],
   ['insert', '-', 2, 'ADD ---> xtz']]

  In [4]: compare(["abc", "abc"], ["abc", "acc", "xtz"], rep_rate=50)
  [['tag', 'index_a', 'index_b', 'data'],
   ['equal', 0, 0, 'abc'],
   ['replace', 1, 1, 'abc ---> acc'],
   ['insert', '-', 2, 'ADD ---> xtz']]

  ```




  ```python
  C:\Windows\system>ipython
  Python 3.7.7 (tags/v3.7.7:d7c567b08f, Mar 10 2020, 10:41:24) [MSC v.1900 64 bit (AMD64)]
  Type 'copyright', 'credits' or 'license' for more information
  IPython 7.21.0 -- An enhanced Interactive Python. Type '?' for help.

  In [1]: from cdiffer import *

  In [2]: %timeit dist('coffee', 'cafe')
     ...: %timeit dist(list('coffee'), list('cafe'))
     ...: %timeit dist(tuple('coffee'), tuple('cafe'))
     ...: %timeit dist(iter('coffee'), iter('cafe'))
     ...: %timeit dist(range(4), range(5))
     ...: %timeit dist('coffee', 'xxxxxx')
     ...: %timeit dist('coffee', 'coffee')
  125 ns ± 0.534 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  677 ns ± 2.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  638 ns ± 3.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  681 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  843 ns ± 3.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  125 ns ± 0.417 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  50.5 ns ± 0.338 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

  In [3]: %timeit similar('coffee', 'cafe')
     ...: %timeit similar(list('coffee'), list('cafe'))
     ...: %timeit similar(tuple('coffee'), tuple('cafe'))
     ...: %timeit similar(iter('coffee'), iter('cafe'))
     ...: %timeit similar(range(4), range(5))
     ...: %timeit similar('coffee', 'xxxxxx')
     ...: %timeit similar('coffee', 'coffee')
  123 ns ± 0.301 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  680 ns ± 2.64 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  647 ns ± 1.78 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  680 ns ± 7.57 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  848 ns ± 4.19 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  130 ns ± 0.595 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  54.8 ns ± 0.691 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

  In [4]: %timeit differ('coffee', 'cafe')
      ...: %timeit differ(list('coffee'), list('cafe'))
      ...: %timeit differ(tuple('coffee'), tuple('cafe'))
      ...: %timeit differ(iter('coffee'), iter('cafe'))
      ...: %timeit differ(range(4), range(5))
      ...: %timeit differ('coffee', 'xxxxxx')
      ...: %timeit differ('coffee', 'coffee')
  735 ns ± 4.18 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.36 µs ± 5.17 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.31 µs ± 5.25 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.37 µs ± 5.04 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.33 µs ± 5.32 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.07 µs ± 6.75 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  638 ns ± 3.67 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

  In [5]: a = dict(zip('012345', 'coffee'))
      ...: b = dict(zip('0123', 'cafe'))
      ...: %timeit dist(a, b)
      ...: %timeit similar(a, b)
      ...: %timeit differ(a, b)
  524 ns ± 2.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  539 ns ± 2.23 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.07 µs ± 1.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

  In [6]: %timeit compare("coffee", "cafe")
      ...: %timeit compare([list("abc"), list("abc")], [list("abc"), list("acc"), list("xtz")], rep_rate=50)
      ...: %timeit compare(["abc", "abc"], ["abc", "acc", "xtz"], rep_rate=40)
      ...: %timeit compare(["abc", "abc"], ["abc", "acc", "xtz"], rep_rate=50)
  844 ns ± 3.88 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  3.32 µs ± 6.92 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  1.16 µs ± 3.94 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  1.3 µs ± 31.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
  ```


pkgId: 05863163af1859e91d272fa1a6ec291d4d0c65ccb8713fec51d473f153d2f2a8
name: python-cdist
arch: src
version: 7.0.0
epoch: 0
release: 1
summary: A Usable Configuration Management System
url: https://cdi.st
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdist-7.0.0-1.src.rpm
checksum_type: sha256
description:
          cdist is a usable configuration management system.
          It adheres to the KISS principle and is being used in small up to
          enterprise grade environments.
          cdist is an alternative to other configuration management systems like
          cfengine, bcfg2, chef and puppet.


pkgId: 4c53fd2a3fda8b69626ccf865b2e43a3b4a03d3dac645c575344f95da8e355df
name: python-cdk-alexa-skill
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A construct library for deploying Alexa Skills with the AWS CDK.
url: https://github.com/aws-samples/cdk-alexa-skill
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-alexa-skill-2.0.4-1.src.rpm
checksum_type: sha256
description:
  This is a CDK construct library for creating an Alexa Skill.

  This library currently supports NodeJS and Python.



  Install with npm

  ```bash
  $ npm install cdk-alexa-skill
  ```

  Install with pip

  ```bash
  $ pip install cdk-alexa-skill
  ```



  * Version 2.x is compatible with the CDK v2.
  * Version 1.x is compatible with the CDK v1. There won't be regular updates for this.





  ```javascript
  import * as cdk from '@aws-cdk/core';
  import * as lambda from '@aws-cdk/aws-lambda';
  import { Skill } from 'cdk-alexa-skill';

  const skillBackendLambdaFunction = new lambda.Function(this, 'Function', {
      ...
  });

  const skill = new Skill(this, 'Skill', {
      endpointLambdaFunction: skillBackendLambdaFunction, // @aws-cdk/aws-lambda.IFunction object containing backend code for the Alexa Skill
      skillPackagePath: 'src/skill-package', // path to your skill package
      alexaVendorId: 'XXXXXXXXXX', // vendor ID of Alexa Developer account
      lwaClientId: 'XXXXXXXXXX', // client ID of LWA Security Profile
      lwaClientSecret: cdk.SecretValue.secretsManager('lwa-client-secret'), // @aws-cdk/core.SecretValue object containing client secret of LWA Security Profile
      lwaRefreshToken: cdk.SecretValue.secretsManager('lwa-refresh-token') // @aws-cdk/core.SecretValue object containing refresh token of LWA Security Profile
  });
  ```



  ```python
  from aws_cdk import core
  from aws_cdk import aws_lambda as lambda_
  from cdk_alexa_skill import Skill

  skill_backend_lambda_function = lambda_.Function(self, 'Function',
      ...)

  skill = Skill(self, 'Skill',
      endpoint_lambda_function=skill_backend_lambda_function, # aws_cdk.aws_lambda.IFunction object containing backend code for the Alexa Skill
      skill_package_path='src/skill_package', # path to your skill package
      alexa_vendor_id='XXXXXXXXXX', # vendor ID of Alexa Developer account
      lwa_client_id='XXXXXXXXXX', # client ID of LWA Security Profile
      lwa_client_secret=core.SecretValue.secrets_manager('lwa-client-secret'), # @aws-cdk/core.SecretValue object containing client secret of LWA Security Profile
      lwa_refresh_token=core.SecretValue.secrets_manager('lwa-refresh-token')) # @aws-cdk/core.SecretValue object containing refresh token of LWA Security Profile
  ```

  See [example folder](./example) or [this blog post](https://aws.amazon.com/blogs/devops/deploying-alexa-skills-with-aws-cdk/) for a more complete example.



  Contributions of all kinds are welcome and celebrated. Raise an issue, submit a PR, do the right thing.

  See [CONTRIBUTING.md](./CONTRIBUTING.md) for contributing guidelines.



  [MIT](./LICENSE)


pkgId: e2fb39bd0661ce7789826666675697b9b382b0cc7d8fed4c267d42f0b582706a
name: python-cdk-amazon-chime-resources
arch: src
version: 3.2.25
epoch: 0
release: 1
summary: cdk-amazon-chime-resources
url: https://github.com/cdklabs/cdk-amazon-chime-resources.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-amazon-chime-resources-3.2.25-1.src.rpm
checksum_type: sha256
description:
  ![Experimental](https://img.shields.io/badge/experimental-important.svg?style=for-the-badge)

  An AWS Cloud Development Kit (AWS CDK) construct library that allows you to provision Amazon Chime resources with npm and pypi.



  Amazon Chime resources (Amazon Chime Messaging and Amazon Chime PSTN resources) are not natively available in AWS CloudFormation or AWS CDK. Therefore, in order to create these resources with AWS CDK, an AWS Lambda backed custom resource must be used. In an effort to simplify that process, this AWS CDK construct has been created. This AWS CDK construct will create a custom resource and associated Lambda and expose constructs that can be used to create corresponding resources. This construct includes resources for both Amazon Chime Messaging and Amazon Chime PSTN.



  * [Amazon Chime SDK PSTN Resources](PSTNRESOURCES.MD)
  * [Amazon Chime SDK Messaging Resources](MESSAGINGRESOURCES.MD)
  * [Amazon Chime SDK Media Insights Resources](MEDIAINSIGHTS.MD)



  To add to your AWS CDK package.json file:

  ```
  yarn add cdk-amazon-chime-resources
  ```



  Version 3.0 is a potentially breaking change that involves multiple upgrades and changes. Version 3.0 revises the deployment to streamline and make more efficient the multiple configurations. This should result in an increased speed of deployment. All namespaces were updated to the current `chime-sdk-voice`, `chime-sdk-messaging`, `chime-sdk-identity`, or `chime-sdk-media-pipelines` namespace. Along with these changes, IAM policies were reduced where possible. If you encounter issues, please open an Issue.

  > Potential Breaking Change with Streaming Messaging Data
  >
  > As part of the namespace change, this has been updated:
  >
  > ```python
  > const appInstance = new MessagingAppInstance(this, 'appInstance', {
  >   name: 'MessagingAppInstanceExample',
  > });
  > appInstance.streaming([
  >   {
  >     dataType: MessagingDataType.CHANNEL,
  >     resourceArn: kinesisStream.streamArn,
  >   },
  > ]);
  > ```



  This is a work in progress.

  Features that are not supported yet:

  * [ ] Amazon Chime Voice Connector Groups
  * [ ] Amazon Chime Voice Connector Emergency Calling
  * [ ] Updates to created resources



  See [CONTRIBUTING](CONTRIBUTING.md) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: c925899da4f5b1f5652774203ddc53714a1f65535dfc8f048ad76dd164c1f7eb
name: python-cdk-aurora-globaldatabase
arch: src
version: 2.3.652
epoch: 0
release: 1
url: https://github.com/neilkuan/cdk-aurora-globaldatabase.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-aurora-globaldatabase-2.3.652-1.src.rpm
checksum_type: sha256
summary:
  cdk-aurora-globaldatabase is an AWS CDK construct library that provides Cross Region Create Global Aurora RDS Databases.

description:
  [![NPM version](https://badge.fury.io/js/cdk-aurora-globaldatabase.svg)](https://badge.fury.io/js/cdk-aurora-globaldatabase)
  [![PyPI version](https://badge.fury.io/py/cdk-aurora-globaldatabase.svg)](https://badge.fury.io/py/cdk-aurora-globaldatabase)
  ![Release](https://github.com/neilkuan/cdk-aurora-globaldatabase/workflows/release/badge.svg)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-aurora-globaldatabase?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-aurora-globaldatabase?label=pypi&color=blue)



  `cdk-aurora-globaldatabase` is an AWS CDK construct library that allows you to create [Amazon Aurora Global Databases](https://aws.amazon.com/rds/aurora/global-database/) with AWS CDK in Typescript or Python.



  **Amazon Aurora Global Databases** is designed for multi-regional Amazon Aurora Database clusters that span across different AWS regions. Due to the lack of native cloudformation support, it has been very challenging to build with cloudformation or AWS CDK with the upstream `aws-rds` construct.

  `cdk-aurora-globaldatabase` aims to offload the heavy-lifting and helps you provision and deploy cross-regional **Amazon Aurora Global Databases** simply with just a few CDK statements.



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-aurora-globaldatabase
  or
  npm install cdk-aurora-globaldatabase@latest

  // for CDKv1
  npm install cdk-aurora-globaldatabase@cdkv1
  ```







  ```python
  import { GlobalAuroraRDSMaster, InstanceTypeEnum, GlobalAuroraRDSSlaveInfra } from 'cdk-aurora-globaldatabase';
  import { App, Stack, CfnOutput } from 'aws-cdk-lib';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';
  // new app .
  const mockApp = new App();

  // setting two region env config .
  const envSingapro  = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-southeast-1' };
  const envTokyo = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-northeast-1' };

  // create stack main .
  const stackM = new Stack(mockApp, 'testing-stackM',{env: envTokyo});
  const vpcPublic = new ec2.Vpc(stackM,'defaultVpc',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'masterVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const  globaldbM = new GlobalAuroraRDSMaster(stackM, 'globalAuroraRDSMaster',{
    instanceType: InstanceTypeEnum.R5_LARGE,
    vpc: vpcPublic,
    rdsPassword: '1qaz2wsx',
  });
  globaldbM.rdsCluster.connections.allowDefaultPortFrom(ec2.Peer.ipv4(`${process.env.MYIP}/32`))

  // create stack slave infra or you can give your subnet group.
  const stackS = new Stack(mockApp, 'testing-stackS',{env: envSingapro});
  const vpcPublic2 = new ec2.Vpc(stackS,'defaultVpc2',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'secondVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const globaldbS = new GlobalAuroraRDSSlaveInfra(stackS, 'slaveregion',{vpc: vpcPublic2,subnetType:ec2.SubnetType.PUBLIC });

  // so we need to wait stack slave created first .
  stackM.addDependency(stackS)


  new CfnOutput(stackM, 'password', { value: globaldbM.rdsPassword });
  // add second region cluster
  globaldbM.addRegionalCluster(stackM,'addregionalrds',{
    region: 'ap-southeast-1',
    dbSubnetGroupName: globaldbS.dbSubnetGroup.dbSubnetGroupName,
  });
  ```

  ![like this ](./image/Mysql-cluster.jpg)



  ```python
  import { GlobalAuroraRDSMaster, InstanceTypeEnum, GlobalAuroraRDSSlaveInfra } from 'cdk-aurora-globaldatabase';
  import { App, Stack, CfnOutput } from 'aws-cdk-lib';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';
  import * as _rds from 'aws-cdk-lib/aws-rds';

  const mockApp = new App();
  const envSingapro  = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-southeast-1' };
  const envTokyo = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-northeast-1' };

  const stackM = new Stack(mockApp, 'testing-stackM',{env: envTokyo});
  const vpcPublic = new ec2.Vpc(stackM,'defaultVpc',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'masterVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });

  // Note if you use postgres , need to give the same value in engineVersion and  dbClusterpPG's engine .
  const globaldbM = new GlobalAuroraRDSMaster(stackM, 'globalAuroraRDSMaster',{
    instanceType: InstanceTypeEnum.R5_LARGE,
    vpc: vpcPublic,
    rdsPassword: '1qaz2wsx',
    engineVersion: _rds.DatabaseClusterEngine.auroraPostgres({
      version: _rds.AuroraPostgresEngineVersion.VER_12_11}),
    dbClusterpPG: new _rds.ParameterGroup(stackM, 'dbClusterparametergroup', {
      engine: _rds.DatabaseClusterEngine.auroraPostgres({
        version: _rds.AuroraPostgresEngineVersion.VER_12_11,
      }),
      parameters: {
        'rds.force_ssl': '1',
        'rds.log_retention_period': '10080',
        'auto_explain.log_min_duration': '5000',
        'auto_explain.log_verbose': '1',
        'timezone': 'UTC+8',
        'shared_preload_libraries': 'auto_explain,pg_stat_statements,pg_hint_plan,pgaudit',
        'log_connections': '1',
        'log_statement': 'ddl',
        'log_disconnections': '1',
        'log_lock_waits': '1',
        'log_min_duration_statement': '5000',
        'log_rotation_age': '1440',
        'log_rotation_size': '102400',
        'random_page_cost': '1',
        'track_activity_query_size': '16384',
        'idle_in_transaction_session_timeout': '7200000',
      },
    }),
  });
  globaldbM.rdsCluster.connections.allowDefaultPortFrom(ec2.Peer.ipv4(`${process.env.MYIP}/32`))

  const stackS = new Stack(mockApp, 'testing-stackS',{env: envSingapro});
  const vpcPublic2 = new ec2.Vpc(stackS,'defaultVpc2',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'secondVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const globaldbS = new GlobalAuroraRDSSlaveInfra(stackS, 'slaveregion',{
    vpc: vpcPublic2,subnetType:ec2.SubnetType.PUBLIC,
  });

  stackM.addDependency(stackS)


  new CfnOutput(stackM, 'password', { value: globaldbM.rdsPassword });
  // add second region cluster
  globaldbM.addRegionalCluster(stackM,'addregionalrds',{
    region: 'ap-southeast-1',
    dbSubnetGroupName: globaldbS.dbSubnetGroup.dbSubnetGroupName,
  });
  ```



  ```bash
  cdk deploy
  ```



  ```bash
  cdk destroy
  ```



  [![Stargazers repo roster for @neilkuan/cdk-aurora-globaldatabase](https://reporoster.com/stars/neilkuan/cdk-aurora-globaldatabase)](https://github.com/neilkuan/cdk-aurora-globaldatabase/stargazers)
  [![Forkers repo roster for @neilkuan/cdk-aurora-globaldatabase](https://reporoster.com/forks/neilkuan/cdk-aurora-globaldatabase)](https://github.com/neilkuan/cdk-aurora-globaldatabase/network/members)


pkgId: b03714b0b0805e3cde18b5c335899f8a5d268d64c077884296baaf056c0b2705
name: python-cdk-aws-discord-notifiers
arch: src
version: 0.0.288
epoch: 0
release: 1
summary: A package that vends constructs to notify about AWS resources via discord
url: https://github.com/awlsring/cdk-aws-discord-notifiers.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-aws-discord-notifiers-0.0.288-1.src.rpm
checksum_type: sha256
description:
  This is a CDK construct library the vends constructs used to notify via discord about various resources and services.



  The following constructs are available:

  `MonthlyCostNotifier` - This construct will notify a discord webhook with a formatted embed of the monthly billing for the account.
  `TrueNasAlertNotifier` - Creates resources to ingest a TrueNAS SNS alert by sending it to a lambda where it is parsed and sent to a discord webhook.



  This provider is built for the following languages:

  * Javascript/Typescript
  * Python
  * C#

  Details on how to find these packages are below and on [ConstructHub](https://constructs.dev/packages/@awlsring/cdk-aws-discord-notifiers)



  Javascript/Typescript package is available on NPM.

  The npm package is viewable at https://www.npmjs.com/package/@awlsring/cdk-aws-discord-notifiers

  ```bash
  npm install @awlsring/cdk-aws-discord-notifiers
  ```



  Python package is available on PyPi.

  The pypi package is viewable at https://pypi.org/project/cdk-aws-discord-notifiers/

  ```bash
  pip install cdk-aws-discord-notifiers
  ```



  C# package is available on Nuget.

  The nuget package is viewable at https://www.nuget.org/packages/awlsring.CdkAwsDiscordNotifiers/

  ```bash
  dotnet add package awlsring.CdkAwsDiscordNotifiers
  ```


pkgId: bcb62705f32995f50788ba3996459a9c240aa035c548d067f525b59573e57375
name: python-cdk-aws-iotfleetwise
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: L2 CDK construct to provision AWS IoT Fleetwise
url: https://github.com/aws-samples/cdk-aws-iotfleetwise.git
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-aws-iotfleetwise-0.3.7-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-aws-iotfleetwise.svg)](https://badge.fury.io/js/cdk-aws-iotfleetwise)
  [![PyPI version](https://badge.fury.io/py/cdk-aws-iotfleetwise.svg)](https://badge.fury.io/py/cdk-aws-iotfleetwise)
  [![release](https://github.com/aws-samples/cdk-aws-iotfleetwise/actions/workflows/release.yml/badge.svg)](https://github.com/aws-samples/cdk-aws-iotfleetwise/actions/workflows/release.yml)



  L2 CDK construct to provision AWS IoT Fleetwise





  ```sh
  npm install cdk-aws-iotfleetwise
  ```

  [API Reference](doc/api-typescript.md)



  ```sh
  pip install cdk-aws-iotfleetwise
  ```

  [API Reference](doc/api-python.md)



  ```python
  import {
    SignalCatalog,
    VehicleModel,
    Vehicle,
    Campaign,
    CanVehicleInterface,
    CanVehicleSignal,
    SignalCatalogBranch,
    TimeBasedCollectionScheme,
  } from 'cdk-aws-iotfleetwise';

  const signalCatalog = new SignalCatalog(stack, 'SignalCatalog', {
    database: tsDatabaseConstruct,
    table: tsHeartBeatTableConstruct,
    nodes: [
      new SignalCatalogBranch({
        fullyQualifiedName: 'Vehicle',
      }),
      new SignalCatalogSensor({
        fullyQualifiedName: 'Vehicle.EngineTorque',
        dataType: 'DOUBLE',
      }),
    ],
  });

  const model_a = new VehicleModel(stack, 'ModelA', {
    signalCatalog,
    name: 'modelA',
    description: 'Model A vehicle',
    networkInterfaces: [
      new CanVehicleInterface({
        interfaceId: '1',
        name: 'vcan0',
      }),
    ],
    signals: [
      new CanVehicleSignal({
        fullyQualifiedName: 'Vehicle.EngineTorque',
        interfaceId: '1',
        messageId: 401,
        factor: 1.0,
        isBigEndian: true,
        isSigned: false,
        length: 8,
        offset: 0.0,
        startBit: 0,
      }),
    ],
  });

  const vin100 = new Vehicle(stack, 'vin100', {
    vehicleName: 'vin100',
    vehicleModel: model_a,
    createIotThing: true,
  });

  new Campaign(stack, 'Campaign', {
    name: 'TimeBasedCampaign',
    target: vin100,
    collectionScheme: new TimeBasedCollectionScheme(cdk.Duration.seconds(10)),
    signals: [new CampaignSignal('Vehicle.EngineTorque')],
  });
  ```



  To deploy a simple end-to-end example you can use the following commands

  ```sh
  yarn install
  npx projen && npx projen compile

  npx cdk -a lib/integ.full.js deploy -c key_name=mykey

  npx cdk -a lib/integ.full.js deploy -c key_name=mykey -c use_s3=true
  ```

  Where `mykey` is an existing keypair name present in your account.
  The deploy takes about 15 mins mostly due to compilation of the IoT FleetWise agent in the
  EC2 instance that simulate the vehicle. Once deploy is finshed, data will start to show up in your Timestream table.



  Warning: this construct should be considered at alpha stage and is not feature complete.

  * Implement updates for all the custom resources
  * Conditional campaigns



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more
  information.



  This code is licensed under the MIT-0 License. See the LICENSE file.


pkgId: 5499472c32f1808a6b84e34b80eaa377cd4bdebcefa94ccad57c728a069d19d0
name: python-cdk-aws-lambda-powertools-layer
arch: src
version: 3.8.0
epoch: 0
release: 1
summary: Powertools for AWS Lambda layer for python and typescript
url: https://github.com/awslabs/cdk-aws-lambda-powertools-layer.git
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-aws-lambda-powertools-layer-3.8.0-1.src.rpm
checksum_type: sha256
description:
  This is a custom construct that will create AWS Lambda Layer with Powertools for AWS Lambda for Python or NodeJS library. There are different
  ways how to create a layer and when working with CDK you need to install the library, create a zip file and wire it
  correctly. With this construct you don't have to care about packaging and dependency management. Create a construct
  and add it to your function. The construct is an extension of the
  existing [`LayerVersion`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.LayerVersion.html) construct
  from the CDK library, so you have access to all fields and methods.

  > ⚠️ **This construct uses docker to build and bundle the dependencies!**

  See the [API](API.md) for details.

  ```python
  import {LambdaPowertoolsLayer} from 'cdk-aws-lambda-powertools-layer';
  import {RuntimeFamily } from "aws-cdk-lib/aws-lambda";

    const powertoolsLayerPython = new LambdaPowertoolsLayer(this, 'TestLayer', {runtimeFamily: RuntimeFamily.PYTHON});
    const powertoolsLayerNodeJS = new LambdaPowertoolsLayer(this, 'TestLayer', {runtimeFamily: RuntimeFamily.NODEJS});
  ```

  Python

  ```python
  from cdk_aws_lambda_powertools_layer import LambdaPowertoolsLayer

  powertoolsLayer = LambdaPowertoolsLayer(self, 'PowertoolsLayer')
  ```

  The layer will be created during the CDK `synth` step and thus requires Docker.



  TypeSript/JavaScript:

  ```shell
  npm i cdk-aws-lambda-powertools-layer
  ```

  Python:

  ```shell
  pip install cdk-aws-lambda-powertools-layer
  ```





  A single line will create a layer with Powertools for AWS Lambda (Python). For NodeJS you need to specifically set the `runtimeFamily: Runtime.NODEJS` property.

  ```python
  from cdk_aws_lambda_powertools_layer import LambdaPowertoolsLayer

  powertoolsLayer = LambdaPowertoolsLayer(self, 'PowertoolsLayer')
  ```

  You can then add the layer to your funciton:

  ```python
  from aws_cdk import aws_lambda

  aws_lambda.Function(self, 'LambdaFunction',
                              code=aws_lambda.Code.from_asset('function'),
                              handler='app.handler',
                              layers=[powertoolsLayer])
  ```

  You can specify the powertools version by passing the optional `version` paramter, otherwise the construct will take the
  latest version from pypi repository.

  ```python
  LambdaPowertoolsLayer(self, 'PowertoolsLayer', version='1.24.0')
  ```

  Additionally, powertools have extras depenedncies such as
  Pydantic, [documented here](https://awslabs.github.io/aws-lambda-powertools-python/latest/#lambda-layer). This is not
  included by default, and you have to set this option in the construct definition if you need it:

  ```python
  LambdaPowertoolsLayer(self, 'PowertoolsLayer', include_extras=True)
  ```

  Full example:

  ```python
  from aws_cdk import Stack, aws_lambda
  from cdk_aws_lambda_powertools_layer import LambdaPowertoolsLayer
  from constructs import Construct


  class LayerTestStack(Stack):

      def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
          super().__init__(scope, construct_id, **kwargs)

          powertoolsLayer = LambdaPowertoolsLayer(
              self, 'PowertoolsLayer', include_extras=True, version='1.24.0')

          aws_lambda.Function(self, 'LambdaFunction',
                              code=aws_lambda.Code.from_asset('function'),
                              handler='app.handler',
                              layers=[powertoolsLayer])

  ```



  Full example for TypeScript:

  ```python
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { LambdaPowertoolsLayer } from 'cdk-aws-lambda-powertools-layer';
  import { Code, Function, Runtime } from 'aws-cdk-lib/aws-lambda';
  import * as path from 'path';

  export class CdkPowertoolsExampleStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);

      const powertoolsLayer = new LambdaPowertoolsLayer(this, 'TestLayer', {
        version: '1.22.0',
        includeExtras: true
      });

      new Function(this, 'LambdaFunction', {
        code: Code.fromAsset(path.join('./function')),
        handler: 'app.handler',
        layers: [powertoolsLayer],
      });
    }
  }
  ```


pkgId: ec2eda9e97bae89ab27dac3ebabb1cd47b3d117a44abf1263e937aca52362fd8
name: python-cdk-budget-notifier
arch: src
version: 0.3.38
epoch: 0
release: 1
summary: A simple AWS budget notifier.
url: https://github.com/stefanfreitag/cdk-budget-notifier.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-budget-notifier-0.3.38-1.src.rpm
checksum_type: sha256
description:
  Setup a AWS Budget notification using AWS Cloud Development Kit (CDK).
  The construct supports notifying to

  * users via e-mail. Up to 10 e-mail addresses are supported
  * an SNS topic
    The SNS topic needs to exist and publishing to the topic needs to be allowed.



  [API.md](API.md)





  This example is handy for keeping control over your private AWS Bill.
  For myself I aim to not spent more than 10 Euro / 10 USD per month and this alarm
  reminds me.

  ```python
  const app = new cdk.App();
  const stack = new Stack(app, "BudgetNotifierStack");

  // Define the SNS topic and setup the resource policy
  const topic = new Topic(stack, "topic");

  const statement = new PolicyStatement({
    effect: Effect.ALLOW,
    principals: [new ServicePrincipal("budgets.amazonaws.com")],
    actions: ["SNS:Publish"],
    sid: "Allow budget to publish to SNS"
  });
  topic.addToResourcePolicy(statement);

  // Setup the budget notifier and pass the ARN of the SNS topic
  new BudgetNotifier(stack, "notifier", {
    topicArn: topic.topicArn,
    // Filter on the availability zone `eu-central-1`
    availabilityZones: ["eu-central-1"],
    costCenter: "myCostCenter",
    // Limit and unit defining the budget limit
    limit: 10,
    unit: "USD",
    // When breaching the threshold of 85% of the 10 USD notifications will be send out.
    threshold: 85,
    notificationType: NotificationType.FORECASTED,
  });
  ```



  As alternative to the notification via SNS you can specify a list of e-mail
  recipients.

  ```python
  const app = new cdk.App();
  const stack = new Stack(app, "BudgetNotifierStack");

  new BudgetNotifier(stack, 'notifier', {
    recipients: ['john.doe@foo.bar'],
    // Filter on the availability zone `eu-central-1`
    availabilityZones: ['eu-central-1'],
    costCenter: 'MyCostCenter',
    // Limit and unit defining the budget limit
    limit: 10,
    unit: 'USD',
    // When breaching the threshold of 85% of the 10 USD notifications will be send out.
    threshold: 85,
    notificationType: NotificationType.FORECASTED,
  });
  ```



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section --><!-- prettier-ignore-start --><!-- markdownlint-disable --><table>
    <tr>
      <td align="center"><a href="https://github.com/dedominicisfa"><img src="https://avatars.githubusercontent.com/u/23100791?v=4" width="100px;" alt=""/><br /><sub><b>dedominicisfa</b></sub></a></td>
      <td align="center"><a href="http://p6m7g8.github.io"><img src="https://avatars.githubusercontent.com/u/34295?v=4" width="100px;" alt=""/><br /><sub><b>Philip M. Gollucci</b></sub></a></td>
    </tr>
  </table><!-- markdownlint-restore --><!-- prettier-ignore-end --><!-- ALL-CONTRIBUTORS-LIST:END -->



  * [AWS Cloud Development Kit (CDK)](https://github.com/aws/aws-cdk)
  * [Cost Explorer filters](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-filtering.html)


pkgId: 9d69e87d5aef3ed8d2799933996ee37e6ba94ffeabaaaea83747683a58aecd4d
name: python-cdk-budibase
arch: src
version: 0.0.495
epoch: 0
release: 1
summary: Use AWS CDK to create budibase server
url: https://github.com/neilkuan/cdk-budibase.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-budibase-0.0.495-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-budibase.svg)](https://badge.fury.io/js/cdk-budibase)
  [![PyPI version](https://badge.fury.io/py/cdk-budibase.svg)](https://badge.fury.io/py/cdk-budibase)
  [![release](https://github.com/neilkuan/cdk-budibase/actions/workflows/release.yml/badge.svg)](https://github.com/neilkuan/cdk-budibase/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-budibase?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-budibase?label=pypi&color=blue)



  > [`BudiBase`](https://github.com/Budibase/budibase)  is open source! is Build apps, forms, and workflows that perfectly fit your business - so you can move forward, faster. Best of all.
  > Use AWS CDK to create budibase server.
  > data store in efs

  * base resource:

    * vpc, ecs cluster, ecs service, efs

  > ref: https://medium.com/devops-techable/learn-how-to-use-the-efs-mount-point-in-your-ecs-cluster-running-fargate-with-aws-cdk-e5c9df435c8b



  ![](./docs/arch.png)



  ![](/docs/cdk-deploy.png)

  ```bash

  npx aws-cdk@latest diff --app='npx ts-node src/integ.api.ts'


  npx aws-cdk@latest deploy --app='npx ts-node src/integ.api.ts'


  npx aws-cdk@latest destroy --app='npx ts-node src/integ.api.ts'
  ```



  ```python
  import { BudiBaseBaseResource } from 'cdk-budibase';

  const app = new App();
  const env = {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION,
  };

  const stack = new Stack(app, 'MyStack', { env });
  new BudiBaseBaseResource(stack, 'BudiBaseBaseResource');
  ```



  ![](/docs/efs.png)



  ![](/docs/admin-sign-up.png)
  ![](/docs/budibase-console.png)


pkgId: 6620eca6e62d12d7553be9fa6244d9c3b23f726971a710ff50818b433183817d
name: python-cdk-certbot-dns-route53
arch: src
version: 2.4.301
epoch: 0
release: 1
summary: Create Cron Job Via Lambda, to update certificate and put it to S3 Bucket.
url: https://github.com/neilkuan/cdk-certbot-dns-route53.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-certbot-dns-route53-2.4.301-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-certbot-dns-route53.svg)](https://badge.fury.io/js/cdk-certbot-dns-route53)
  [![PyPI version](https://badge.fury.io/py/cdk-certbot-dns-route53.svg)](https://badge.fury.io/py/cdk-certbot-dns-route53)
  [![Release](https://github.com/neilkuan/cdk-certbot-dns-route53/actions/workflows/release.yml/badge.svg?branch=main)](https://github.com/neilkuan/cdk-certbot-dns-route53/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-certbot-dns-route53?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-certbot-dns-route53?label=pypi&color=blue)



  **cdk-certbot-dns-route53** is a CDK construct library that allows you to create [Certbot](https://github.com/certbot/certbot) Lambda Function on AWS with CDK, and setting schedule cron job to renew certificate to store on S3 Bucket.



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-certbot-dns-route53
  or
  npm install cdk-certbot-dns-route53@latest

  // for CDKv1
  npm install cdk-certbot-dns-route53@cdkv1
  ```

  💡💡💡 please click [here](https://github.com/neilkuan/cdk-certbot-dns-route53/tree/cdkv1#readme), if you are using aws-cdk v1.x.x version.💡💡💡

  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53Job } from 'cdk-certbot-dns-route53';

  const devEnv = {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION,
  };

  const app = new cdk.App();

  const stack = new cdk.Stack(app, 'lambda-certbot-dev', { env: devEnv });

  new CertbotDnsRoute53Job(stack, 'Demo', {
    certbotOptions: {
      domainName: '*.example.com',
      email: 'user@example.com',
    },
    zone: r53.HostedZone.fromHostedZoneAttributes(stack, 'myZone', {
      zoneName: 'example.com',
      hostedZoneId:  'mockId',
    }),
    destinationBucket: s3.Bucket.fromBucketName(stack, 'myBucket', 'mybucket'),
  });
  ```



  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53Job } from 'cdk-certbot-dns-route53';

  const mockApp = new cdk.App();
  const stack = new cdk.Stack(mockApp, 'teststack', { env: devEnv });
  const bucket = new s3.Bucket(stack, 'testingBucket');
  const zone = r53.HostedZone.fromHostedZoneAttributes(stack, 'zone', {
    zoneName: mock.zoneName, hostedZoneId: mock.zoneId,
  });
  new CertbotDnsRoute53Job(stack, 'Testtask', {
    certbotOptions: {
      domainName: 'example.com',
      email: 'user@example.com',
      customPrefixDirectory: '/',
    },
    zone,
    destinationBucket: bucket,
    schedule: events.Schedule.cron({ month: '2' }),
    architecture: lambda.Architecture.ARM_64, // <- like this way.
  });
  ```



  ![](./images/lambda-logs.png)



  ![](./images/s3-bucket.png)



  > Support enabled Lambda Function Url.

  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53JobPython } from 'cdk-certbot-dns-route53';

  const mockApp = new cdk.App();
  const stack = new cdk.Stack(mockApp, 'teststack', { env: devEnv });
  const bucket = new s3.Bucket(stack, 'testingBucket');
  const zone = r53.HostedZone.fromHostedZoneAttributes(stack, 'zone', {
    zoneName: mock.zoneName, hostedZoneId: mock.zoneId,
  });
  new CertbotDnsRoute53JobPython(stack, 'Testtask', {
    certbotOptions: {
      domainName: 'example.com',
      email: 'user@example.com',
      customPrefixDirectory: '/',
    },
    zone,
    destinationBucket: bucket,
    schedule: events.Schedule.cron({ month: '2' }),
    enabledLambdaFunctionUrl: true,
  });
  ```


pkgId: 7cba402bf7fe00186b18c047de01f6027384d491ccec399ff411377446e41303
name: python-cdk-cloudformation-datadog-monitors-monitor
arch: src
version: 4.8.0a7
epoch: 0
release: 1
summary: Datadog Monitor 4.8.0
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-datadog-monitors-monitor-4.8.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Datadog::Monitors::Monitor` v4.8.0.



  Datadog Monitor 4.8.0



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Datadog::Monitors::Monitor \
    --publisher-id 7171b96e5d207b947eb72ca9ce05247c246de623 \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/7171b96e5d207b947eb72ca9ce05247c246de623/Datadog-Monitors-Monitor \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Datadog::Monitors::Monitor`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fdatadog-monitors-monitor+v4.8.0).
  * Issues related to `Datadog::Monitors::Monitor` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 0de31a5d06e8561b51e9917d0c12b052a4b2599b85721c8c5cf2541c3b6ccd07
name: python-cdk-cloudformation-redis-cloud-database
arch: src
version: 1.0.0a7
epoch: 0
release: 1
summary: CloudFormation template for Pro Database.
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-redis-cloud-database-1.0.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Redis::Cloud::Database` v1.0.0.



  CloudFormation template for Pro Database.



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Redis::Cloud::Database \
    --publisher-id 991a427d4922adc55ddc491f1a3a0421a61120bc \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/991a427d4922adc55ddc491f1a3a0421a61120bc/Redis-Cloud-Database \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Redis::Cloud::Database`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fredis-cloud-database+v1.0.0).
  * Issues related to `Redis::Cloud::Database` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 9ee53c98808cf18f52778d853dcf3bf8199ba51608a7826b66aa9ee13f9e10db
name: python-cdk-cloudformation-redis-cloud-subscription
arch: src
version: 1.0.0a7
epoch: 0
release: 1
summary: CloudFormation template for Pro Subscription.
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-redis-cloud-subscription-1.0.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Redis::Cloud::Subscription` v1.0.0.



  CloudFormation template for Pro Subscription.



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Redis::Cloud::Subscription \
    --publisher-id 991a427d4922adc55ddc491f1a3a0421a61120bc \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/991a427d4922adc55ddc491f1a3a0421a61120bc/Redis-Cloud-Subscription \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Redis::Cloud::Subscription`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fredis-cloud-subscription+v1.0.0).
  * Issues related to `Redis::Cloud::Subscription` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 059ba1d110150e40aa3b5f321a526d7ebbe3bed12a44cf6553372036c3f82e5b
name: python-cdk-cloudformation-redis-cloudformation-prodatabase
arch: src
version: 1.0.0a7
epoch: 0
release: 1
summary: CloudFormation template for Pro Database.
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-redis-cloudformation-prodatabase-1.0.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Redis::CloudFormation::ProDatabase` v1.0.0.



  CloudFormation template for Pro Database.



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Redis::CloudFormation::ProDatabase \
    --publisher-id 68686e85baeed40bdffe29c5e35183528a2e7174 \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/68686e85baeed40bdffe29c5e35183528a2e7174/Redis-CloudFormation-ProDatabase \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Redis::CloudFormation::ProDatabase`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fredis-cloudformation-prodatabase+v1.0.0).
  * Issues related to `Redis::CloudFormation::ProDatabase` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 11c6f6e616475b10645a1894587d24cc75b007683bb80942e34409d88f6cb143
name: python-cdk-cloudformation-redis-cloudformation-prosubscription
arch: src
version: 1.0.0a7
epoch: 0
release: 1
summary: CloudFormation template for Pro Subscription.
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-redis-cloudformation-prosubscription-1.0.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Redis::CloudFormation::ProSubscription` v1.0.0.



  CloudFormation template for Pro Subscription.



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Redis::CloudFormation::ProSubscription \
    --publisher-id 68686e85baeed40bdffe29c5e35183528a2e7174 \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/68686e85baeed40bdffe29c5e35183528a2e7174/Redis-CloudFormation-ProSubscription \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Redis::CloudFormation::ProSubscription`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fredis-cloudformation-prosubscription+v1.0.0).
  * Issues related to `Redis::CloudFormation::ProSubscription` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 05ee4575efad557bee562b343049af6d2b1578ec086bb3c9a0d49570661b85ee
name: python-cdk-cloudformation-redis-cloudformation-subscriptionpeering
arch: src
version: 1.0.0a7
epoch: 0
release: 1
summary: CloudFormation template for Subscription Peering.
url: https://github.com/cdklabs/cdk-cloudformation.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudformation-redis-cloudformation-subscriptionpeering-1.0.0a7-1.src.rpm
checksum_type: sha256
description:
  > AWS CDK [L1 construct](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) and data structures for the [AWS CloudFormation Registry](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html) type `Redis::CloudFormation::SubscriptionPeering` v1.0.0.



  CloudFormation template for Subscription Peering.



  In order to use this library, you will need to activate this AWS CloudFormation Registry type in your account. You can do this via the AWS Management Console or using the [AWS CLI](https://aws.amazon.com/cli/) using the following command:

  ```sh
  aws cloudformation activate-type \
    --type-name Redis::CloudFormation::SubscriptionPeering \
    --publisher-id 68686e85baeed40bdffe29c5e35183528a2e7174 \
    --type RESOURCE \
    --execution-role-arn ROLE-ARN
  ```

  Alternatively:

  ```sh
  aws cloudformation activate-type \
    --public-type-arn arn:aws:cloudformation:us-east-1::type/resource/68686e85baeed40bdffe29c5e35183528a2e7174/Redis-CloudFormation-SubscriptionPeering \
    --execution-role-arn ROLE-ARN
  ```

  You can find more information about activating this type in the [AWS CloudFormation documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html).



  This library is auto-generated and published to all supported programming languages by the [cdklabs/cdk-cloudformation](https://github.com/cdklabs/cdk-cloudformation) project based on the API schema published for `Redis::CloudFormation::SubscriptionPeering`.

  * Issues related to this generated library should be [reported here](https://github.com/cdklabs/cdk-cloudformation/issues/new?title=Issue+with+%40cdk-cloudformation%2Fredis-cloudformation-subscriptionpeering+v1.0.0).
  * Issues related to `Redis::CloudFormation::SubscriptionPeering` should be reported to the [publisher](undefined).



  Distributed under the Apache-2.0 License.


pkgId: 3c09cdcbe30807ef1efc55b6d14cbe5dfcfa158f5c2a9afc6d882667a723edb5
name: python-cdk-cloudwatch-alarm-chatbot
arch: src
version: 1.0.33
epoch: 0
release: 1
summary: cdk-cloudwatch-alarm-chatbot
url: https://github.com/lvthillo/cdk-cloudwatch-alarm-chatbot.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-cloudwatch-alarm-chatbot-1.0.33-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-cloudwatch-alarm-chatbot.svg)](https://badge.fury.io/js/cdk-cloudwatch-alarm-chatbot)
  [![PyPI version](https://badge.fury.io/py/cdk-cloudwatch-alarm-chatbot.svg)](https://badge.fury.io/py/cdk-cloudwatch-alarm-chatbot)
  ![Release](https://github.com/lvthillo/cdk-cloudwatch-alarm-chatbot/workflows/release/badge.svg)



  A CDK construct which creates an SNS AWS ChatBot (Slack) integration for CloudWatch alarms.



  Example use of construct

  ```python
  import * as cdk from 'aws-cdk-lib';
  import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
  import * as cloudwatch_actions from 'aws-cdk-lib/aws-cloudwatch-actions';
  import * as sqs from 'aws-cdk-lib/aws-sqs';
  import { CdkCloudWatchAlarmChatBot } from 'cdk-cloudwatch-alarm-chatbot';
  import { Construct } from 'constructs';

  export class CdkDemoStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props?: cdk.StackProps) {
      super(scope, id, props);

      const queue = new sqs.Queue(this, 'HelloCdkQueue', {
        visibilityTimeout: cdk.Duration.seconds(300)
      });

      const qMetric = queue.metric('ApproximateNumberOfMessagesVisible');

      const alarm = new cloudwatch.Alarm(this, 'Alarm', {
        metric: qMetric,
        threshold: 100,
        evaluationPeriods: 3,
        datapointsToAlarm: 2
      });

      const slackAlarmIntegration = new CdkCloudWatchAlarmChatBot(this, 'SlackIntegration', {
        topicName: 'slack-alarm',
        slackChannelId: 'xxx',
        slackWorkSpaceId: 'yyy',
      });

      alarm.addAlarmAction(new cloudwatch_actions.SnsAction(slackAlarmIntegration.topic));

    }
  }
  ```

  Test Alarm:

  ```
  $ aws cloudwatch set-alarm-state --alarm-name "xxx" --state-value ALARM --state-reason "testing purposes"
  ```


pkgId: c66319bcce5cef8b346a3acd66610a5769707606152c38a67f559961c719ede8
name: python-cdk-code-server
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: CDK Construct for a VSCode Server development environment on EC2
url: https://github.com/badmintoncryer/cdk-code-server.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-code-server-0.0.10-1.src.rpm
checksum_type: sha256
description:
  This is a CDK Construct for creating a VSCode server on an Amazon Linux EC2 instance.

  [![View on Construct Hub](https://constructs.dev/badge?package=cdk-code-server)](https://constructs.dev/packages/cdk-code-server)

  [![Open in Visual Studio Code](https://img.shields.io/static/v1?logo=visualstudiocode&label=&message=Open%20in%20Visual%20Studio%20Code&labelColor=2c2c32&color=007acc&logoColor=007acc)](https://open.vscode.dev/badmintoncryer/cdk-code-server)
  [![npm version](https://badge.fury.io/js/cdk-code-server.svg)](https://badge.fury.io/js/cdk-code-server)
  [![Build Status](https://github.com/badmintoncryer/cdk-code-server/actions/workflows/build.yml/badge.svg)](https://github.com/badmintoncryer/cdk-code-server/actions/workflows/build.yml)
  [![Release Status](https://github.com/badmintoncryer/cdk-code-server/actions/workflows/release.yml/badge.svg)](https://github.com/badmintoncryer/cdk-code-server/actions/workflows/release.yml)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![npm downloads](https://img.shields.io/npm/dm/cdk-code-server.svg?style=flat)](https://www.npmjs.com/package/cdk-code-server)

  ![CDK VSCode Server Construct](./images/code-server.png)

  You can easily access Visual Studio Code Server through your browser and start development.

  In the EC2 security group's inbound rules, communication from the Internet is not allowed, ensuring secure access to the VSCode server.
  Additionally, by passing the IAM policy to be attached to the EC2 instance as a property, you can grant appropriate permissions for AWS access within VSCode.



  Install the package:

  ```bash
  npm install cdk-code-server
  ```

  Use it in your CDK stack:

  ```python
  import { CodeServer } from 'cdk-code-server';

  new CodeServer(this, 'CodeServer');
  ```

  You can customize the instance type, vpc, and other properties:

  ```python
  import { CodeServer } from 'cdk-code-server';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';

  // Use an existing VPC
  declare const vpc: ec2.IVpc;
  // Use an existing policy as a instance role
  declare const policy: iam.PolicyStatememnt;

  new CodeServer(this, 'CodeServer', {
    vpc,
    // Specify the instance type
    // Default is c7g.2xlarge
    instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
    // Specify the CPU architecture
    // Default is ec2.AmazonLinuxCpuType.ARM_64
    cpuType: ec2.AmazonLinuxCpuType.X86_64,
    // Specify the IAM policy for the instance role
    // Default is a policy that has an administrator access
    policy,
    // Specify the size of the EBS volume
    // Default is 30 GB
    volumeSize: 100,
  });
  ```



  After the stack is deployed, you can access to the server via EC2 instance connect endpoint(EIC endpoint) and create connection to the VSCode server:



  Access the EC2 management console in the AWS Console, and connect to your EC2 instance via the EIC Endpoint.

  Select the Instance ID > Connect > EC2 Instance Connect > Connect using EC2 Instance Connect Endpoint > Connect

  If the following screen is displayed, you're all set.

  ![EC2 Instance Connect](./images/console.png)



  Execute the following command to start the VSCode server:

  ```sh
  [ec2-user@ip-10-0-0-23 ~]$ code tunnel service install
  [2024-06-10 02:10:42] info Using GitHub for authentication, run `code tunnel user login --provider <provider>` option to change this.
  To grant access to the server, please log into https://github.com/login/device and use code 3811-9932
  ```

  Next, open your browser and go to [https://github.com/login/device](https://github.com/login/device), enter the code, and complete the authentication.

  In the example above, enter '3811-9932' > Continue > Continue > Authorize-Visual-Studio-Code.

  Return to the EC2 instance, run the code tunnel again, and open the displayed URL [https://vscode.dev/tunnel/ip-{privateIp}{region}](https://vscode.dev/tunnel/ip-%7BprivateIp%7D%7Bregion%7D) in your browser.

  ```sh
  [ec2-user@ip-10-0-0-23 ~]$ code tunnel
  *
  * Visual Studio Code Server
  *
  * By using the software, you agree to
  * the Visual Studio Code Server License Terms (https://aka.ms/vscode-server-license) and
  * the Microsoft Privacy Statement (https://privacy.microsoft.com/en-US/privacystatement).
  *
  [2024-06-10 02:11:44] info Creating tunnel with the name: ip-10-0-0-23ap-north
  [2024-06-10 02:11:44] info Open this link in your browser https://vscode.dev/tunnel/ip-10-0-0-23ap-north

  Connected to an existing tunnel process running on this machine.

  Open this link in your browser https://vscode.dev/tunnel/ip-10-0-0-23ap-north
  ```

  VSCode will open, and you'll be prompted with "What type of account did you use to start this tunnel?" Select `GitHub`.

  At this point, the GitHub authentication screen may appear again, so press Authorize.

  Once you open the terminal, you’re all set.

  ![VSCode](./images/vscode.png)


pkgId: eaa2420e027ba1db8c2c8a2179f905ffba87b78f8a32abb97b46337072dfe8f0
name: python-cdk-codepipeline-badge-notification
arch: src
version: 2.0.78
epoch: 0
release: 1
summary: cdk-codepipeline-badge-notification
url: https://github.com/kimisme9386/cdk-codepipeline-badge-notification
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-codepipeline-badge-notification-2.0.78-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-codepipeline-badge-notification.svg)](https://badge.fury.io/js/cdk-codepipeline-badge-notification)
  [![PyPI version](https://badge.fury.io/py/cdk-codepipeline-badge-notification.svg)](https://badge.fury.io/py/cdk-codepipeline-badge-notification)
  [![Release](https://github.com/kimisme9386/cdk-codepipeline-badge-notification/actions/workflows/release.yml/badge.svg)](https://github.com/kimisme9386/cdk-codepipeline-badge-notification/actions/workflows/release.yml)





  * Generate badge when AWS CodePipeline state change
  * Update GitHub commit status when AWS CodePipeline state change
  * Notification for chat bot provider

    * Slack
    * Google Chat
    * Telegram





  ```
  npm install cdk-codepipeline-badge-notification
  or
  npm install cdk-codepipeline-badge-notification@latest
  or
  npm install cdk-codepipeline-badge-notification@^2.0.0
  ```



  ```
  npm install cdk-codepipeline-badge-notification@cdkv1
  or
  npm install cdk-codepipeline-badge-notification@^1.0.6
  ```



  ```python
  import { CodePipelineBadgeNotification } from 'cdk-pipeline-badge-notification';
  import * as cdk from '@aws-cdk/core';
  import * as codePipeline from '@aws-cdk/aws-codepipeline';

  const app = new cdk.App();
  const env = {
    region: process.env.CDK_DEFAULT_REGION,
    account: process.env.CDK_DEFAULT_ACCOUNT,
  };
  const stack = new cdk.Stack(app, 'codepipeline-badge-notification', { env });

  const pipeline = new codePipeline.Pipeline(stack, 'TestPipeline', {
    pipelineName: 'testCodePipeline',
    crossAccountKeys: false,
  });

  new CodePipelineBadgeNotification(stack, 'CodePipelineBadgeNotification', {
    pipelineArn: pipeline.pipelineArn,
    gitHubTokenFromSecretsManager: {
      secretsManagerArn:
        'arn:aws:secretsmanager:ap-northeast-1:111111111111:secret:codepipeline/lambda/github-token-YWWmII',
      secretKey: 'codepipeline/lambda/github-token',
    },
    notification: {
      stageName: 'production',
      ssmSlackWebHookUrl: '/chat/google/slack',
      ssmGoogleChatWebHookUrl: '/chat/google/webhook',
      ssmTelegramWebHookUrl: '/chat/telegram/webhook',
    },
  });
  ```

  > :warning: telegram webhook url from ssm parameter which the URL is not include `text` query string

  > gitHubTokenFromSecretsManager and notification is optional



  ```python
  new CodePipelineBadgeNotification(stack, 'CodePipelineBadgeNotification', {
    pipelineArn: pipeline.pipelineArn,
  });
  ```


