# packages

pkgId: 034cac603b2b4ca11ec76a69be37563ee6cd2b8d1f787ab5391b3594a7211b68
name: python-comgra
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: A package for analyzing computation graphs
url: https://github.com/FlorianDietz/comgra
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comgra-0.11.5-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="src/assets/brandcrowd_logos/FullLogo.png" title="ComgraLogo" height="300" width="300"/>
  </p>

  - [Overview](#overview)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Tutorial](#tutorial---debugging-an-example-network)
    - [The Task and the Architecture](#the-task-and-the-architecture)
    - [Initial Exploration](#initial-exploration)
    - [Finding the Bug](#finding-the-bug)
  - [Other Features](#other-features)
  - [Custom Visualization](#custom-visualization)
  - [Dynamic Recordings](#dynamic-recordings)
  - [Known Issues](#known-issues)
  - [Future Development: Anomaly Detection and Correlation Analysis](#future-development-anomaly-detection-and-correlation-analysis)



  Comgra helps you analyze and debug neural networks in pytorch.
  It records your network internals, visualizes the computation graph, and provides a GUI to investigate any part of your network from a variety of viewpoints.
  Move along the computation graph, check for outliers, investigate both individual data points and summary statistics, compare gradients, automatically record special cases, and more.
  Comgra records everything that could be relevant to you, and allows you to inspect your network's behavior from many different angles.

  Suitable both for novices and for professional neural architecture designers: Create a simple visualization of your network to understand what is happening under the hood, or perform advanced analyses and trace anomalies through the computation graph.

  | <img src="src/assets/screenshots_for_tutorial/main_overview.png" width="100%"/>
  | -

  Comgra's GUI has three parts:
  * A dependency graph that visualizes how the tensors in your network depend on each other
  * Selectors that let you choose under what lens you want to inspect the tensors
  * An output that lists both summary statistics and the values of individual neurons for the selected tensors
  <details>
    <summary><b>Notes on the dependency graph</b></summary>

    Each rectangle in the dependency graph is a node that represents a named tensor. The colors indicate the roles of the tensor in the network, such as input, intermediate result, parameter, etc.

    When you select a node it becomes highlighted, along with all nodes that it depends on (to the left) and that depend on it (to the right). Only the links for the selected node are shown by default to avoid visual clutter, but by clicking on one node after the other you can explore the entire dependency graph.

    If a node has a dotted border on one side, it indicates that it does not have any dependency (left) or dependent (right) on that iteration. If a connection is drawn with a thinner line, it indicates that some of the tensors in the node have this connection, but the currently selected one does not. In the example network of the tutorial, this is the case for the node 'subnet_pre', which summarizes all four parameters of the module with that name. You can use the "Role of Tensor" selector to switch to another parameter in that module, which will change the connections.

    The dependency graph is generated automatically based on the computation graph used by pytorch and the names you assign to tensors through comgra. It is a subgraph of the computation graph, but it is much easier to understand because it is smaller and skips all the distracting details.

    This cutting away of details also makes it easier to compare different variants of architectures: Their computation graphs may look different, but the simplified dependency graphs are the same.
  </details>



  Install with pip:

  ```bash
  pip install comgra
  ```



  To use comgra, modify your python code with the following commands in the appropriate places. Most of it just tells comgra what you are currently doing so that it knows how to associate the tensors you register. The file `src/scripts/run.py` ([found here](https://github.com/FlorianDietz/comgra/blob/main/src/scripts/run.py)) contains a documented example that you can copy and that will be explained in detail below.

  ```python
  import comgra
  from comgra.recorder import ComgraRecorder

  comgra.my_recorder = ComgraRecorder(...)

  comgra.my_recorder.track_module(...)

  comgra.my_recorder.add_note(...)

  comgra.my_recorder.record_kpi_in_graph()


  comgra.my_recorder.start_batch(...)

  comgra.my_recorder.start_iteration(...)

  comgra.my_recorder.register_tensor(...)



  comgra.my_recorder.add_tensor_connection(...)

  comgra.my_recorder.record_current_gradients(...)

  comgra.my_recorder.finish_iteration()

  comgra.my_recorder.finish_batch()

  comgra.my_recorder.finalize()
  ```

  Not all of these commands are necessary. The following is a minimal example. You can [run it directly on Colab](https://colab.research.google.com/drive/1RuMHlv_pp1_t_tkZfojV0LVR-Zo7QoVv?usp=sharing)

  ```python
  import torch
  import torch.nn as nn
  import torch.optim as optim
  import comgra
  from comgra.objects import DecisionMakerForRecordingsFrequencyPerType
  from comgra.recorder import ComgraRecorder


  class SimpleModel(nn.Module):
      def __init__(self):
          super(SimpleModel, self).__init__()
          self.layer0 = nn.Linear(5, 5)
          self.layer1 = nn.Linear(5, 5)

      def forward(self, x):
          x = self.layer0(x)
          return self.layer1(x)


  comgra.my_recorder = ComgraRecorder(
      comgra_root_path="/my/path/for/storing/data",
      group="name_of_experiment_group",
      trial_id="example_trial",
      decision_maker_for_recordings=DecisionMakerForRecordingsFrequencyPerType(min_training_steps_difference=10),
  )
  comgra.my_recorder.add_note("This is an optional log message that will show up in the 'Notes' tab.")


  model = SimpleModel()
  criterion = nn.MSELoss()
  optimizer = optim.SGD(model.parameters(), lr=0.01)
  comgra.my_recorder.track_module("main_model", model)


  inputs = torch.randn(100, 5)
  targets = 2 * inputs + torch.randn(100, 5) * 0.1


  num_epochs = 100
  for epoch in range(num_epochs):
      comgra.my_recorder.start_batch(epoch, inputs.shape[0])
      comgra.my_recorder.start_iteration()
      
      comgra.my_recorder.register_tensor("inputs", inputs, is_input=True)
      outputs = model(inputs)
      comgra.my_recorder.register_tensor("outputs", outputs)
      comgra.my_recorder.register_tensor("targets", targets, is_target=True)
      loss = criterion(outputs, targets)
      comgra.my_recorder.register_tensor("loss", loss, is_loss=True)
      comgra.my_recorder.record_kpi_in_graph("loss", "", loss)
      
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()
      comgra.my_recorder.record_current_gradients(f"gradients")
      comgra.my_recorder.finish_iteration()
      comgra.my_recorder.finish_batch()
  comgra.my_recorder.finalize()
  ```

  When your code runs, comgra will store data in the folder you specified with `ComgraRecorder(comgra_root_path="/my/path/for/storing/data", group="name_of_experiment_group")`.
  In the process, it will automatically organize everything, extract statistics, and build the dependency graph.

  To start the GUI and visualize your results, run
  ```bash
  comgra --path "/my/path/for/storing/data/name_of_experiment_group"
  ```

  Note that "--path" should include both the "comgra_root_path" and the "group" parameter you gave to ComgraRecorder. You can start the GUI while the script is still running and it will automatically load new data as it becomes available.




  The file `src/scripts/run.py` ([found here](https://github.com/FlorianDietz/comgra/blob/main/src/scripts/run.py)) trains a neural network on an example task. This network contains a subtle bug, and in this tutorial we will show you how you can use comgra to find that bug.

  For convenience, you can run the file from the commandline using
  ```bash
  comgra-test-run
  ```

  The results of that run will be stored in a local folder of the library. You can start the GUI on this data by running

  ```bash
  comgra --use-path-for-test-run
  ```

  You can also [check out the GUI on Colab](https://colab.research.google.com/drive/15PEZjxFG6CVTewHBXidTXMsM6CCQM6kC?usp=sharing), with pre-generated data.




  We use a synthetic task that is designed to test a neural network's ability to generalize to longer sequences, while being very simple and human-interpretable. The input is a sequence of N tuples of 5 numbers between -1.0 and 1.0. The network should treat these as 5 separate, independent sequences. Its objective is to sum up each of the sequences and decide if their sum is positive. The target consists of 5 numbers, one for each sequence, which is a 1 if the sum is positive and a 0 otherwise.

  Our architecture is a simple recurrent neural network that is composed of three submodules. It's nothing fancy, but illustrates how comgra can be integrated into an architecture.

  We run two variants of the architecture. The original variant contains a bug, which we will discover later in this section of the Readme. For convenience, we run both trials in one script, but in a real use case the second variant would have been implemented and run later, after finding the bug. In the GUI, you can switch between the two variants with the 'Trial' selector.



  As a first step, let's look at network summary information, graphs, and the notes created by the script. To do so, select "Network" and "Notes" respectively at the main radio button at the top left of the screen.

  | <img src="src/assets/screenshots_for_tutorial/notes_info.png" width="100%"/>
  | -

  The Notes tab shows anything that we logged with `add_note()`. If we scroll down, we see that performance improves, but it does not look very good.

  | <img src="src/assets/screenshots_for_tutorial/graphs_info.png" width="100%"/>
  | -

  The Graphs tab shows KPIs we logged with `record_kpi_in_graph()`. This visualization is based on plotly and is interactive, similar to tensorboard. We can see that the loss only converges slowly and that the network generalizes poorly: The curves for 15 iterations and 20 iterations, which are only used during testing, are much higher than the rest.

  | <img src="src/assets/screenshots_for_tutorial/network_info.png" width="100%"/>
  | -

  The Network tab shows a recursive breakdown of all network parameters, in tree form. We can see that none of the submodules has such a small number of parameters that it could form a bottleneck, which rules out one kind of bug.

  There is also a "Visualization" tab. This is an advanced feature described under [Custom Visualization](#custom-visualization). It is not relevant for this tutorial.

  Next, let's click the "Tensors" button and start the main analysis.

  | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/00_start.png" width="100%"/>
  | -

  Let's start by setting some selectors to some arbitrary but sensible values to get an initial overview:

  * Set the "Type of training Step" to "05_iterations" so that we are only shown training steps that ran for exactly 5 iterations.
  * Select the last iteration: Note that the Node for the Loss only appears in the computational graph if the last iteration is selected, because a loss is only applied on the last iteration.
  * Select the "input" node.
  * Set "Batch or sample" to "Sample 0": The values at the bottom of the screen now show the values for only the first element of the batch. This makes it possible to investigate how the network reacts to specific examples, while "Mean over the batch" is more useful for investigating how statistics change over time. Note that the values "mean", "abs_mean", "std", and "abs_max" at the bottom of the screen are statistics over the value dimension of the tensor. Setting "Batch or sample" to "Mean over the batch" means that it additionally calculates the mean over the batch dimension after calculating the statistic over the value dimension. This combination gives you a lot of flexibility in how you look at the data.

  | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/01.png" width="100%"/>
  | -

  We have currently selected the "input" node in the dependency graph (the green node at the top left). The lines that go from the selected node to other nodes indicate dependencies. In the following we move along the dependency graph by clicking on subsequent nodes until we get to the "Loss" node. (Note that a different node is highlighted in each image).

  <details>
    <summary><b>Click here to expand: Walking through the dependency graph</b></summary>

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/02.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/03.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/04.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/05.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/06.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/07.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_nodes/08.png" width="100%"/>
    | -
  </details>

  Note how the values displayed at the bottom update immediately whenever you select a new node, or change a selector. This allows you to investigate many different hypotheses quickly, without waiting for results or having to restart your experiment.

  Next, we investigate if the network parameters show any suspicious behavior. To do so, we select a node that represents a network parameter and move the slider for the training step.

  <details>
    <summary><b>Click here to expand: Varying the training step</b></summary>

    | <img src="src/assets/screenshots_for_tutorial/slideshow_parameter_updates/00.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_parameter_updates/01.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_parameter_updates/02.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/slideshow_parameter_updates/03.png" width="100%"/>
    | -
  </details>

  Judging by the way _abs_mean_ and _abs_max_ change over the course of training, the network parameters specialize and become more extreme, but they do not explode. This looks like healthy behavior.

  The best way to get a feel for the GUI is to try it yourself. There is a lot of basic information that is helpful to investigate, both as a sanity check and to get a better intuitive feel for your network's internals. Try the following:

  * Look at the inputs, outputs and targets for different samples and at different training steps. Is the target what it should be? Does the output approximate it well? Do intermediate tensors all have the same value range, or are some of them larger or smaller than others? Can you notice any irregularities when you compare different batches?
  * So far we have only looked at the tensors produced by the network, but there is also a selector to look at the gradients on the tensors instead. Check the gradients on some tensors. Do they point in the right direction? Does it look like the gradients are ever too large or too small? Comgra makes it easy to find vanishing or exploding gradients, and to pinpoint at which node in the computation graph the problem starts.
  * In our example script, we defined a node called "helper_partial_sums", which can be found at the top left of the dependency graph. Unlike other nodes, this node contains several different tensors with different roles, and you can switch between them using the "Role of tensor" selector. We use this feature here to store helper values for debugging, because the partial sums are relevant for solving the task but wouldn't normally get stored by the network, so it is convenient to make them available in the GUI. Note that the "Role of tensor" feature is also useful if you are working with self-attention or another mechanism that can work on a variable number of tensors.

  All of these exploratory analyses are easy and fast to do, so they are often worth the time. They can save you hours or days of frustration by catching a simple mistake early. Even if you find no mistakes, they can still be helpful to get a better understanding of your network's behavior.



  As we noticed before, the code works, but not very well.

  If you paid close attention during the exploratory analysis you may have noticed something odd:
  The neurons of the output tensor should be either 1 or 0. While values close to 1 are reached early in training, values close to 0 are reached only very late. If we look at the mean over the batch, the values are much greater than expected, too.

  Why could this be?

  If we look at the tensor immediately preceding the output in the dependency graph ("subnet_out__out"), we notice that its positive values are much higher than its negative values. This is a problem, because that tensor is fed into a sigmoid function!

  From here on, we jump into our code to find out what's going on. If the source of the problem is not clear to you, then it can help to just register more intermediate tensors with comgra and run the experiment again, inspecting both the values and the gradients on each tensor. If you have seen this sort of behavior before, you may find the culprit quickly: Our subnetworks use an activation function, _leaky_relu_ with a negative slope of 0.01, and they apply this activation at every layer, including the last one.

  This means that while our submodules can produce negative outputs, they learn to do so at only 1% of the rate they should.

  We have found the source of the bug.

  In the `src/scripts/run.py` [script](https://github.com/FlorianDietz/comgra/blob/main/src/scripts/run.py) we also run a second trial in which this bug is fixed: We simply skip the activation function on the last layer of submodules.

  The results of this can be seen by switching the "Trial" selector from "trial_bugged_original_version" to "trial_no_activation_function_on_output_layer".

  If you inspect this second trial, you will notice that the bug is gone. The loss curves of the second trial, in the 'Graphs' section, show much faster convergence than they did before and also generalized better to higher lengths.

  <details>
    <summary><b>Click here to expand: Differences in convergence speed and length generalization</b></summary>

    | <img src="src/assets/screenshots_for_tutorial/comparison_loss_graphs/original.png" width="100%"/>
    | -

    | <img src="src/assets/screenshots_for_tutorial/comparison_loss_graphs/fixed.png" width="100%"/>
    | -
  </details>

  This was the sort of bug that harmed performance but still allowed the network to solve the task. Without the inspection abilities offered by comgra, it would normally be next to impossible to detect a bug like this.



  While fixing this bug clearly has a positive effect based on the loss curves, the overall loss and accuracy still seem pretty bad.

  Where does the high loss come from? Is it a bug, or is the task just difficult?

  To investigate this, we use the node "helper_partial_sums", which we define in the run.py file as a helper. The values stored here are not used by the network, but they help us with debugging.

  Intuitively, we would expect the task to be more difficult if the final sum of a sequence is close to 0. The node "helper_partial_sums" stores this final sum. Comparing this value with the node "loss_per_sample" for several samples confirms that the network has a high loss in exactly the situations where "helper_partial_sums" is close to 0.

  This finding suggest the next line of research to improve our model: Modify the network to be better able to handle small numbers with high numerical accuracy. Doing so is beyond the scope of this tutorial.




  Comgra gives you a lot of different ways to look at your data. Here are some suggestions for what you can do with it:

  * Go through toy examples step-by-step. This is normally time-consuming and often not worth it, but comgra makes it easy.
  * Use the _type_of_execution_ parameter of `start_batch()` to ensure that rarely occurring special cases still get recorded regularly and are easy to find. You can also use it to mark inputs with specific properties you are interested in. For example, to mark especially simple or especially hard inputs, or inputs with extreme outlier values.
  * Check for anomalous gradients. Do any of your activation functions unexpectedly kill gradients? Are you using attention mechanisms with extreme weights that drive down the gradients? Are gradients non-zero, but with wildly different magnitudes in different parts of the network or under different circumstances?
  * Trace NaNs and Extreme Values. Where did the anomalous value come from? Just find the first training step where any tensor is NaN or abs().mean() is extreme. Then find out why this may be, by looking at the gradients on that step and previous ones.
  * Check if network initialization is sensible. What do tensors and their gradients look like on the very first training steps? Do their means change significantly? If so, this suggests that the initialization can be improved.
  * Check a tensor's variance over the batch dimension. If this decreases, we may have mode collapse. If it increases unboundedly, it suggests that a tensor is receiving consistently one-directional gradients that makes the tensor more and more extreme over time, instead of approximating a target value more accurately.
  * Challenge your intuition. Sometimes the network acts differently than you would intuitively expect. In one concrete case that happened to me, I was interpolating a tensor as y=a*w+b*(1-w) and was surprised to see that the value for "a" received a gradient pushing it away from the target value of "y". This actually made mathematical sense for the values I had (a=1.1, b=0.1, w=0.5, target of y = 1), but it was not intuitive to me. Comgra enabled me to notice this discrepancy between my intuition and the network's actual behavior, and that allowed me to improve the network. I have encountered several cases like these, where my intuition about the optimal learned attention weights was different from what was actually learned on a toy task, which taught me a lot about the network dynamics.
  * Check if any neurons end up with interpretable values. For example, the weights in attention mechanisms tell you what the network pays attention to. But there are also more subtle interpretable values that would be difficult to inspect without comgra, unless you already know what to look for before you run the experiment. For example, you can compare the mean absolute values of the two branches in a residual connection to find out if the network ignores a calculation and relies on residuals.





  You can integrate your own custom visualization into comgra to take advantage of comgra's recording and filtering features.

  To do so, use the `--visualization-file` parameter when you start the comgra GUI and provide the path to a python file with your custom visualization code. The GUI will now display an additional tab for your custom visualization.

  This visualization can depend on all the same filters and selectors that the rest of comgra uses, allowing you to apply comgra's flexibility to the specific visualization requirements of your task. For example, if you work on transformer models in LLMs, you could supply a script that can color-code the text fed into the transformer based on its attention weights so that you can look for correlations between the text and network weights.

  The file should define a function called `create_visualization()`. Check the file `scripts/example_custom_visualization.py` for an example. This file is used automatically when you run `comgra --use-path-for-test-run` is run every time you change the selection in the GUI while the 'Visualization' tab is selected.

  The file `scripts/example_custom_visualization.py` results in the following visualization in the GUI: It creates a graph for the helper variable "helper_partial_sums", which shows how our five sequences change over the course of the iterations. This graph automatically adjusts when you change the training step or the "Batch or sample" selector.

  | <img src="src/assets/screenshots_for_tutorial/custom_visualization.png" width="100%"/>
  | -





  By default, you have to decide at the beginning of a training step whether you want comgra to record it. However. it can happen that you only know at the end of a training step if the step was interesting enough to be worth recording, or if any particular part of the batch was more interesting than the rest.

  We therefore provide an optional feature to decide retroactively, at the end of the batch, if you want to record, and what parts of the batch you want to record. This could e.g. help with debugging by automatically finding and recording the very first step where gradients start going out of bounds.

  Combine this with anomaly detection and comgra will be able to extract the most interesting and informative samples for you and make them easily accessible using selectors.

  To use Dynamic Recordings, simply give `None` as the value for `type_of_execution` in the `start_batch()` function. Then, at the end of the batch but before you call `finish_batch()`, call `decide_recording_of_batch()`. This function takes the actual value of `type_of_execution` und which the recording should be saved (if you provide `None` again, the recording will be skipped). It also takes an argument `category_per_sample`, which selects which indices of the batch should be recorded: Each sample in the batch may be assigned a category. Comgra will try to record an equal number of samples from each category.


  Note that Dynamic Recordings are not used by default because they are more computationally expensive.

  <details>
    <summary><b>Click here to expand: About the slowdown</b></summary>

    When Dynamic Recordings are used, comgra has to apply .requires_grad to all tensors in advance even if it later finds out that no recording is necessary, and this increases runtime.

    If you are using a limited number of different `type_of_execution` values to categorize your batches, then you can mitigate this problem with the function `declare_that_all_different_types_of_execution_have_been_encountered()`, which enables comgra to realize that many training steps will not be recorded anyway since all possible `type_of_execution` they could be assigned to are too recent.

    Additionally, Dynamic Recordings may be slower than normal recordings because of additional code on the user's side if you make use of `category_per_sample`: In order to assign a category to each sample in a batch, it is necessary to transfer data from GPU to CPU, and doing this on every training step is costly. This problem can be mitigated by only running this part of your code if `recording_is_active()` returns True.
  </details>





  In order to record gradients, comgra needs to set the 'requires_grad' attribute to True on all tensors you register with it. This does not affect training and should have no negative consequences for most users. However, it can lead to side effects if you make direct use of this attribute in your own code.

  It also means that it can matter where in your code you call `register_tensor()`. If you call it on a tensor that does not have requires_grad set to true already, you should call it immediately after creating the tensor, before using it in any other computation. Otherwise, the computation graph will not be constructed correctly.

  It is not possible to set `requires_grad` to `True` on some types of tensors, which can make `register_tensor()` fail. To deal with this, register a replacement tensor instead and then use `add_tensor_connection()` to ensure they stay connected. Example:

  ```python

  a = torch.tensor([1, 2, 3])

  comgra.my_recorder.register_tensor("my_tensor", a.float())

  b = a * 1.0
  comgra.my_recorder.add_tensor_connection("my_tensor", b)
  ```

  You should also be aware that `requires_grad` is necessary but not sufficient for `add_tensor_connection()` to work: It's possible that a tensor is built from two tensors, one of which has `requires_grad` and the other does not. Comgra won't automatically record the second one in this case and will not notice that anything is amiss. Use `add_tensor_connection()` to manually add connections for these cases.





  A goal for the future development of this tool is the automated detection of anomalies in computational graphs.

  As a first step, we want to detect anomalies to automatically generate warnings such as "Tensor X looks like it suffers from vanishing gradients". There are a large number of possible anomalies that are time-consuming to check manually. It would be very convenient if you could be sure that none of them apply to your model because these things are found automatically.

  As a second step, we want to scan for anomalies that are not harmful in themselves, but notably strange, and look for correlations between them: "If the attention tensor X has very extreme values then tensor Y tends to be sparse." or "The loss is much higher than normal if the sample belongs to category Z."

  This would save a lot of time with debugging, by automatically generating a list of possible reasons for unexpected behavior.

  The goal of this feature is not to detect anomalies with perfect reliability, but to quickly and cheaply generate hints that guide a human's attention in the right direction, to save time.

  Anomalies could be defined in many different ways, and standard tools for causality analysis already exist. If you are interested in a feature like this and/or want to help, please let me know at floriandietz44@gmail.com


pkgId: f513b53b06f5bf46573ce8505022a2f6887993337c1b2f5c0016633dfcc884e9
name: python-comicbot-api
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: A client to retrieve new releases of comic books, filterable by publisher and format.
url: https://pypi.org/project/comicbot-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comicbot-api-0.1.16-1.src.rpm
checksum_type: sha256
description:
  ![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54)


  ![](./docs/source/_static/images/fortress-of-solitude.jpeg)
  <!-- TOC -->
  * [ComicBot API](#comicbot-api)
    * [Requirements](#requirements)
  * [Project Expectations](#project-expectations)
    * [How to get started](#how-to-get-started)
      * [Create a virtual environment](#create-a-virtual-environment)
      * [Enter virtual environment](#enter-virtual-environment)
      * [Install Poetry, the package manager for this project](#install-poetry-the-package-manager-for-this-project)
      * [Build distribution of project](#build-distribution-of-project)
      * [Running Unit Tests](#running-unit-tests)
        * [Pytest to run all unit tests in `test/`](#pytest-to-run-all-unit-tests-in-test)
      * [Pytest to run all unit tests and lint code with `Pylama`](#pytest-to-run-all-unit-tests-and-lint-code-with-pylama)
      * [Linting](#linting)
      * [Deployment](#deployment-)
    * [Roadmap](#roadmap)
  <!-- TOC -->


  - Python 3.9 or above
  - Virtualenv 20.14.1 or above


  - Client library to get new releases, or releases for a given date.
  - Client can filter by the format of releases e.g. 'single-issue' or by publisher e.g. 'marvel'
  - Client should be straight forward and easy to use by using the KISS model (Keep It Simple Stupid)
  - Cache results where possible as not to hit provider with too many requests for the same data



  ```bash
  virtualenv -p python3.9 venv
  ```


  ```bash
  source venv/bin/activate
  ```


  ```bash
  pip install poetry
  ```


  ```bash
  poetry build
  ```
  Build artifacts will be located in `dist/`


  ```bash
  pytest
  ```


  ```bash
  pytest --pylama
  ```


  This project strives to keep the code style in line with [PEP8](https://peps.python.org/pep-0008/).
  To test the project for compliance with PEP8, I use [Pylama](https://github.com/klen/pylama)
  ```bash
  pip install pylama
  ```
  ```bash
  pylama comicbot_api
  ```


  To deploy, one must obtain an API key from the public pypi (https://pypi.org/project/comicbot-api/)
  and add it to the local `poetry` configuration with the following command:
  ```bash
  poetry config pypi-token.pypi <pypi-token>
  ```
  Once we have a valid token, we can push distributions to PyPi.
  ```bash
  poetry build
  poertry publish
  ```
  or do both with
  ```bash
  poetry publish --build
  ```
  ***

  - [ ] Database to cache results from source
  - [ ] Sphinx Automatic Documentation Creation


pkgId: 99498f3f03b6407a1569a2c296d886b47c621d137410dfadbec00e1b3d362e04
name: python-comicbox
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: An API for reading comic archive contents and metadata: CBZ, CBR, CBT and PDF
url: https://github.com/ajslater/comicbox
rpm_license: LGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comicbox-1.2.1-1.src.rpm
checksum_type: sha256
description:
  A comic book archive metadata reader and writer.





  Comicbox reads CBZ, CBR, CBT, and optionally PDF. Comicbox archives and writes
  CBZ archives and PDF metadata.



  Comicbox reads and writes:

  - [ComicRack ComicInfo.xml v2.1 (draft) schema](https://anansi-project.github.io/docs/comicinfo/schemas/v2.1),
  - [Comic Book Lover ComicBookInfo schema](https://code.google.com/archive/p/comicbookinfo/)
  - [CoMet schema](https://github.com/wdhongtw/comet-utils).
  - [PDF Metadata](https://pymupdf.readthedocs.io/en/latest/tutorial.html#accessing-meta-data).
    - Embedding ComicInfo.xml inside PDFS.
  - A variety of filename schemes that encode metadata.



  Comicbox's primary purpose is a library for use by
  [Codex comic reader](https://github.com/ajslater/codex/). The API isn't well
  documented, but you can infer what it does pretty easily here:
  [comicbox.comic_archive](https://github.com/ajslater/comicbox/blob/main/comicbox/comic_archive.py)
  as the primary interface.

  The command line is increasingly useful and can read and write metadata
  recursively and extract pages.



  Comicbox does _not_ use popular metadata database APIs or have a GUI!

  [Comictagger](https://github.com/comictagger/comictagger) is a popular
  alternative. It does most of what Comicbox does but also automatically tags
  comics with the ComicVine API and has a desktop UI.



  <!-- eslint-skip -->

  ```sh
  pip install comicbox
  ```

  Comicbox supports PDFs as an extra when installed like:

  <!-- eslint-skip -->

  ```sh
  pip install comicbox[pdf]
  ```



  Comicbox generally works without any binary dependencies but requires `unrar` be
  on the path to convert CBR into CBZ or extract files from CBRs.





  Type

  <!-- eslint-skip -->

  ```sh
  comicbox -h
  ```

  see the CLI help.



  <!-- eslint-skip -->

  ```sh
  comicbox test.cbz -m "{Tags: a,b,c, story_arcs: {d:1,e:'',f:3}" -m "Publisher: SmallComics" -w cr
  ```

  Will write those tags to comicinfo.xml in the archive.

  Be sure to add spaces after colons so they are detected as valid YAML key value
  pairs. This is easy to forget.

  But it's probably better to use the --print action to see what it's going to do
  before you actually write to the archive:

  <!-- eslint-skip -->

  ```sh
  comicbox test.cbz -m "{Tags: a,b,c, story_arcs: {d:1,e:'',f:3}" -m "Publisher: SmallComics" -p
  ```

  A recursive example:

  <!-- eslint-skip -->

  ```sh
  comicbox --recurse -m "publisher: 'SC Comics'" -w cr ./SmallComicsComics/
  ```

  Will recursively change the publisher to "SC Comics" for every comic found in
  under the SmallComicsComics directory.



  the `-m` command line argument accepts the YAML language for tags. Certain
  characters like `\,:;_()$%^@` are part of the YAML language. To successful
  include them as data in your tags, look up
  ["Escaping YAML" documentation online](https://www.w3schools.io/file/yaml-escape-characters/)



  To delete metadata from the cli you're best off exporting the current metadata,
  editing the file and then re-importing it with the delete previous metadata
  option:

  <!-- eslint-skip -->

  ```sh

  comicbox --export cix "My Overtagged Comic.cbz"

  nvim comicinfo.xml

  comicbox --import comicinfo.xml -p "My Overtagged Comic.cbz"

  comicbox --delete "My Overtagged Comic.cbz"

  comicbox --import comicinfo.xml --write cix "My Overtagged Comic.cbz"
  ```



  The comicbox.yaml format represents the ComicInfo.xml Web tag as an
  `identifiers.url` tag. Fear not, you don't have to remember this. The CLI
  accepts heterogeneous tag types with the `-m` option, so you can type:

  <!-- eslint-skip -->

  ```sh
  comicbox -p -m "Web: https://foo.com" mycomic.cbz
  ```

  and the identifier tag should appear in comicbox.yaml as:

  ```yaml
  identifiers:
    nss: foo.com
    url: https://foo.com
  ```



  Comicbox actually installs three different packages:

  - `comicbox` The main API and CLI script.
  - `comicfn2dict` A separate library for parsing comic filenames into dicts it
    also includes a CLI script.
  - `pdffile` A utility library for reading and writing PDF files with an API like
    Python's ZipFile



  comicbox accepts command line arguments but also an optional config file and
  environment variables.

  The variables have defaults specified in
  [a default yaml](https://github.com/ajslater/comicbox/blob/main/comicbox/config_default.yaml)

  The environment variables are the variable name prefixed with `COMICBOX_`. (e.g.
  COMICBOX_COMICINFOXML=0)



  change logging level:

  <!-- eslint-skip -->

  ```sh
  LOGLEVEL=ERROR comicbox -p <path>
  ```



  You may access most development tasks from the makefile. Run make to see
  documentation.



  I didn't like Comictagger's API, so I built this for myself as an educational
  exercise and to use as a library for
  [Codex comic reader](https://github.com/ajslater/codex/).



  Comicbox supports reading and writing several comic book metadata schemas.



  Comicbox includes a pretty good comic archive filename parser. It can extract a
  number of common fields from comic archive filenames.

  | Location      | Name                  |
  | ------------- | --------------------- |
  | Archive       | The archive filename  |
  | Import/Export | comicbox-filename.txt |



  The pdf metadata standard. Can be exported as an xml file or written directly to
  the pdf itself.

  [Adobe PDF Namespace](https://developer.adobe.com/xmp/docs/XMPNamespaces/pdf/)
  [Adobe PDF Standard](https://opensource.adobe.com/dc-acrobat-sdk-docs/standards/pdfstandards/pdf/PDF32000_2008.pdf)
  § 14.3.3 Document Information Dictionary

  PDF metadata is only read or written from and to PDF files.

  | Location      | Name             |
  | ------------- | ---------------- |
  | Archive       | PDF internal     |
  | Import/Export | pdf-metadata.xml |



  Comicbox will read most any metadata standard it supports from the keywords
  field. If that fails it will consider the keywords field as a comma delimited
  "Tags" field.



  By default Comicbox will write ComicInfo XML to the keywords field (e.g.
  `-w pdf`)

  [Codex](https://github.com/ajslater/codex) supports this because it uses
  Comicbox. Other comic readers do not support PDF embedded ComicInfo.xml, but
  since they already have ComicInfo.xml parsers it's possible that they might
  someday.

  If Comicbox JSON is included in the write formats (e.g. `-w pdf,json`) Comicbox
  will write comicbox.json to the keywords field instead. It is unlikely that any
  other comic reader other than Codex will ever support this.



  An old and uncommon comic metadata standard from a defunct comic book reader.

  [CoMet Specification](http://www.denvog.com/comet/comet-specification/)

  | Location      | Name      |
  | ------------- | --------- |
  | Archive       | comet.xml |
  | Import/Export | comet.xml |



  The Comic Book Lover schema. A rare but still encountered JSON schema. It
  probably survives because Comictagger supports writing it.

  [ComicBookInfo](https://code.google.com/archive/p/comicbookinfo/wikis/Example.wiki)

  | Location      | Name                 |
  | ------------- | -------------------- |
  | Archive       | Zip & Rar Comments   |
  | Import/Export | comic-book-info.json |



  The Comic Rack schema. The de facto standard of comic book metadata. The Comic
  Rack reader is defunct, but the
  [Anansi Project](https://anansi-project.github.io/) now publishes the ComicInfo
  spec and has compatibly and conservatively extended it.

  [Anansi ComicInfo v2.1 Spec](https://anansi-project.github.io/docs/comicinfo/schemas/v2.1)
  Also, an unofficial, undocumented Mylar extension to ComicInfo.xml that encodes
  multiple Story Arcs and Story Arc Numbers as CSV values.

  | Location      | Name          |
  | ------------- | ------------- |
  | Archive       | comicinfo.xml |
  | Import/Export | comicinfo.xml |



  The most useful comic book metadata writer is
  [ComicTagger](https://github.com/comictagger/comictagger). It supports the
  ComicVine API, is extensible to other APIs, and features a nice desktop GUI.
  Internally, Comictagger keeps a metadata object to work with the schemas it
  supports. This schema allows the import and export of that schema.

  [Comictaggger genericmetadata.py](https://github.com/comictagger/comictagger/blob/develop/comicapi/genericmetadata.py)

  This schema may only be useful to developers. The author of ComicTagger offers
  no promises as to the stability of this API and I am very lazy, so the chances
  of this drifting out of date are anyone's guess. It was included because it was
  easy to do.

  | Location      | Name             |
  | ------------- | ---------------- |
  | Archive       | comictagger.json |
  | Import/Export | comictagger.json |



  The comicbox internal data structure which acts as a superset of the above
  schemas to allow interpolating.

  [Comicbox JSON Schema](https://github.com/ajslater/comicbox/blob/main/schemas/comicbox.schema.json)



  | Location      | Name          |
  | ------------- | ------------- |
  | Archive       | comicbox.json |
  | Import/Export | comicbox.json |



  YAML is a superset of JSON, so the JSON schema applies here.

  | Location      | Name          |
  | ------------- | ------------- |
  | Archive       | comicbox.yaml |
  | Import/Export | comicbox.yaml |



  The Comicbox CLI uses "flow style" YAML, which is an all on one line format to
  enter metadata on the command line.

  Specifying metadata on the command line like this is additive.

  | Location      | Name              |
  | ------------- | ----------------- |
  | Comicbox CLI  | -m --metadata     |
  | Archive       | comicbox-cli.yaml |
  | Import/Export | comicbox-cli.yaml |



  There is a special environment variable `DEBUG_TRANSFORM` that will print
  verbose schema transform information


pkgId: 004bef5ba5cb5937a3ce7df65b687d528a0778cf27e7af13c2af37c12516564f
name: python-comicfn2dict
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Parse common comic filenames and return a dict of metadata attributes. Includes a cli.
url: https://github.com/ajslater/comicfn2dict
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comicfn2dict-0.2.4-1.src.rpm
checksum_type: sha256
description:
  An API and CLI for extracting structured comic metadata from filenames.



  <!-- eslint-skip -->

  ```sh
  pip install comicfn2dict
  ```



  <!-- eslint-skip -->

  ```python
  from comicfn2dict import comicfn2dict, dict2comicfn

  path = "Comic Series #001 Title (2024).cbz"

  metadata: dict[str, str| tuple[str,...]] = comicfn2dict(path, verbose=0)

  filename: str = dict2comicfn(metadata, bool=True, verbose=0)
  ```



  <!-- eslint-skip -->

  ```sh
  comicfn2dict "Series Name #01 - Title (2023).cbz"
  {'ext': 'cbz',
  'issue': '001',
  'series': 'Series Name',
  'title': 'Title',
  'year': '2023'}
  ```


pkgId: fd4c3ea27606ad80c4a1f755646049a26c0b09bb1c33c60a45d7ac36cf090681
name: python-comicom
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A script that stitches images together and breaks them in to pages based on available whitespace
url: https://github.com/bajuwa/ComicCompiler
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comicom-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Given a set of images, vertically combines them in to 'pages' where the start/end of the page are solid white (or some other specified colour).
  For more information on installation and how to use comcom, [see our github wiki](https://github.com/bajuwa/ComicCompiler/wiki).

  While you're here, though, you can check out this small demo or [view all demos here](https://github.com/bajuwa/ComicCompiler/blob/master/demos/):
  ![ComCom demo](https://raw.githubusercontent.com/bajuwa/ComicCompiler/master/demos/gui-compile.gif)


pkgId: cb1055a433ac69c1b0c7572dd3d817e4b20c81f831df0aea54cf136bce1fb591
name: python-comicon
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A simple comic conversion library between CBZ/EPUB/MOBI/PDF
url: https://github.com/potatoeggy/comicon
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comicon-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Comicon is a lightweight comic converter library between CBZ, PDF, EPUB, and MOBI that preserves metadata. Once Comicon has converted a comic, it is **guaranteed** that the reverse conversion will restore the original comic with all of its original metadata.



  For a command line interface, please see [Mandown](https://github.com/potatoeggy/mandown).

  ```python
  import comicon

  comicon.convert("comic.cbz", "comic.epub")
  ```



  Amazon's **Kindlegen** is required if you want to convert to MOBI. See [here](https://github.com/ciromattia/kcc/issues/371) for more information.

  Comicon is available from PyPI:

  ```
  pip install comicon
  ```



  | Format | Convert from?      | Convert to?        |
  | ------ | ------------------ | ------------------ |
  | CBZ    | :heavy_check_mark: | :heavy_check_mark: |
  | EPUB   | :heavy_check_mark: | :heavy_check_mark: |
  | PDF    | :heavy_check_mark: | :heavy_check_mark: |
  | MOBI   | :x:                | :heavy_check_mark: |



  - Only EPUB supports a table of contents. CBZ and PDF will encode the table of contents so that it is restored upon converting to EPUB.
  - PDF does not support importing genre data due to a lack of library support. This may be worked around in the future.



  Under the hood, Comicon converts each format into the **Comicon Intermediate Representation (CIR)** — more or less a strictly structured folder, which allows for many guarantees to be made for each input and output plugin. See `comicon.cirtools` for more information.

  For new input and output formats to be added, they should be added in `comicon.inputs` or `comicon.outputs` respectively as a new module and in the `__init__.py` file(s).


pkgId: 0d7b01e302b1f97e14cf3e6fb02c85db1a511d4e85cf9a5202cecb73a8c21284
name: python-comics
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: comics
url: https://github.com/irahorecka/comics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comics-0.3.6-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://static.wikia.nocookie.net/garfield/images/8/83/GoComicsLogo.png/revision/latest/scale-to-width-down/2849?cb=20230628152535" width="50%"/>
  </p>

  <br>

  [GoComics](https://www.gocomics.com/) API wrapper

  [![pypiv](https://img.shields.io/pypi/v/comics.svg)](https://pypi.python.org/pypi/comics)
  [![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
  [![continuous-integration](https://github.com/irahorecka/comics/workflows/continuous-integration/badge.svg?branch=main)](https://github.com/irahorecka/comics/actions)
  [![Licence](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/irahorecka/comics/main/LICENSE)



  ```bash
  pip install comics
  ```



  Find and download the Calvin and Hobbes comic strip published on January 2, 1990:

  ```python
  import comics

  ch = comics.search("calvinandhobbes").date("January 2, 1990")
  ch.download("calvinandhobbes.png")
  ```

  <div align="center">
      <img src="docs/calvinandhobbes.png">
  </div>



  Available comics can be found using the `directory` class:

  ```python
  import comics


  comics.directory.listall()



  comics.directory.search("Calvin and Hobbes")

  ```

  First, pass the desired endpoint to `comics.search`. For example, to search for Calvin and Hobbes comics in english use `comics.search("calvinandhobbes")`; for spanish, use `comics.search("calvinandhobbesenespanol")`.



  Then, search for a comic strip using the `date` or `random_date` method:

  ```python
  import comics


  ch = comics.search("calvinandhobbes").date("2013-05-13")  # Also accepts datetime object


  random_ch = comics.search("calvinandhobbes").random_date()
  ```

  Finally, show, download, or stream the comic strip:

  ```python

  ch.show()



  ch.download()


  ch.stream()
  ```



  An instantiated `search` class will have the following public attributes:

  ```python
  import comics

  garfield = comics.search("garfield")
  garfield.endpoint

  garfield.title

  garfield.start_date

  ```

  An instantiated `search` class with `date` or `random_date` will have the following public attributes:

  ```python
  import comics

  garfield = comics.search("garfield").date("08/20/2000")
  garfield.endpoint

  garfield.title

  garfield.date

  garfield.url

  garfield.image_url

  ```



  An exception will be thrown if the queried date is unregistered or before the comic's origin date:

  ```python
  import comics
  from comics.exceptions import InvalidDateError

  try:
      peanuts = comics.search("peanuts").date("1900-01-01")
      peanuts.download()
  except InvalidDateError:
      print("Whoops, an invalid date was queried.")
  ```

  An exception will be thrown if the queried endpoint is unregistered:

  ```python
  import comics
  from comics.exceptions import InvalidEndpointError

  try:
      invalid_comic = comics.search("invalid_endpoint").date("2000-01-01")
      invalid_comic.download()
  except InvalidEndpointError:
      print("Whoops, an invalid endpoint was queried.")
  ```



  * [Issues Tracker](https://github.com/irahorecka/comics/issues)
  * [Source Code](https://github.com/irahorecka/comics/tree/main/comics)



  If you are having issues or would like to propose a new feature, please use the [issues tracker](https://github.com/irahorecka/comics/issues).

  <div align="center">
      <img src="docs/dilbert.png">
  </div>



  This project is licensed under the MIT license.


pkgId: 5fd9b6b84e334a94fd486e46b713978bc0bf4db7245fdab70407cf48948dd07b
name: python-comictagger
arch: src
version: 1.5.5
epoch: 0
release: 1
summary: A cross-platform GUI/CLI app for writing metadata to comic archives
url: https://github.com/comictagger/comictagger
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comictagger-1.5.5-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/comictagger/comictagger/actions/workflows/build.yaml/badge.svg?branch=develop&event=push)](https://github.com/comictagger/comictagger/actions/workflows/build.yaml)
  [![GitHub release (latest by date)](https://img.shields.io/github/downloads/comictagger/comictagger/latest/total)](https://github.com/comictagger/comictagger/releases/latest)
  [![PyPI](https://img.shields.io/pypi/v/comictagger)](https://pypi.org/project/comictagger/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/comictagger)](https://pypistats.org/packages/comictagger)
  [![Chocolatey package](https://img.shields.io/chocolatey/dt/comictagger?color=blue&label=chocolatey)](https://community.chocolatey.org/packages/comictagger)
  [![PyPI - License](https://img.shields.io/pypi/l/comictagger)](https://opensource.org/licenses/Apache-2.0)

  [![GitHub Discussions](https://img.shields.io/github/discussions/comictagger/comictagger)](https://github.com/comictagger/comictagger/discussions)
  [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/comictagger/community)
  [![Google Group](https://img.shields.io/badge/discuss-on%20groups-%23207de5)](https://groups.google.com/forum/#!forum/comictagger)
  [![Twitter](https://img.shields.io/badge/%40comictagger-twitter-lightgrey)](https://twitter.com/comictagger)
  [![Facebook](https://img.shields.io/badge/comictagger-facebook-lightgrey)](https://www.facebook.com/ComicTagger-139615369550787/)



  ComicTagger is a **multi-platform** app for **writing metadata to digital comics**, written in Python and PyQt.

  ![ComicTagger logo](https://raw.githubusercontent.com/comictagger/comictagger/develop/comictaggerlib/graphics/app.png)



  * Runs on macOS, Microsoft Windows, and Linux systems
  * Get comic information from [Comic Vine](https://comicvine.gamespot.com/)
  * **Automatic issue matching** using advanced image processing techniques
  * **Batch processing** in the GUI for tagging hundreds or more comics at a time
  * Support for **ComicRack** and **ComicBookLover** tagging formats
  * Native full support for **CBZ** digital comics
  * Native read only support for **CBR** digital comics: full support enabled installing additional [rar tools](https://www.rarlab.com/download.htm)
  * Command line interface (CLI) enabling **custom scripting** and **batch operations on large collections**

  For details, screen-shots, and more, visit [the Wiki](https://github.com/comictagger/comictagger/wiki)






  Windows and macOS binaries are provided in the [Releases Page](https://github.com/comictagger/comictagger/releases).

  Just unzip the archive in any folder and run, no additional installation steps are required.



  A pip package is provided, you can install it with:

  ```
   $ pip3 install comictagger[GUI]
  ```

  There are two optional dependencies GUI and CBR. You can install the optional dependencies by specifying one or more of `GUI`,`CBR` or `all` in braces e.g. `comictagger[CBR,GUI]`



  A [Chocolatey package](https://community.chocolatey.org/packages/comictagger), maintained by @Xav83, is provided, you can install it with:
  ```powershell
  choco install comictagger
  ```


   1. Ensure you have python 3.9 installed
   2. Clone this repository `git clone https://github.com/comictagger/comictagger.git`
   3. `pip3 install -r requirements_dev.txt`
   7. `pip3 install .` or `pip3 install .[GUI]`


pkgId: c6a7eb5f6d2b5be5779cae5da4d6f3609ef0def9cd1d51be94afaa613c4ed7c5
name: python-comm
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc.
url: https://github.com/ipython/comm
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comm-0.2.2-1.src.rpm
checksum_type: sha256
description:
  It provides a way to register a Kernel Comm implementation, as per the Jupyter kernel protocol.
  It also provides a base Comm implementation and a default CommManager that can be used.





  We provide default implementations for usage in IPython:

  ```python
  import comm


  class MyCustomComm(comm.base_comm.BaseComm):
      def publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
          
          pass


  comm.create_comm = MyCustomComm
  ```

  This is typically what ipykernel and JupyterLite's pyolite kernel will do.



  ```python
  import comm

  comm.create_comm = custom_create_comm
  comm.get_comm_manager = custom_comm_manager_getter
  ```

  This is typically what xeus-python does (it has its own manager implementation using xeus's C++ messaging logic).



  Libraries like ipywidgets can then use the comms implementation that has been registered by the kernel:

  ```python
  from comm import create_comm, get_comm_manager


  comm_manager = get_comm_manager()
  comm = create_comm()

  comm_manager.register_comm(comm)
  ```

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, Jupyter All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder 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: b0f55870047462c68ae1427ee9b031eecffcc0c7831b19dd59b64b5e85e6288d
name: python-comma-agents
arch: src
version: 0.0.9
epoch: 0
release: 1
url: https://commaagents.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comma-agents-0.0.9-1.src.rpm
checksum_type: sha256
summary:
  A way to elevate your AI workflow with Comma Agents, a versatile Python library designed for seamless AI model integration and automation. Perfect for developers looking to enhance efficiency in local or remote environments, it offers customizable AI flows and scalable solutions. Streamline your projects with Comma Agents, the ideal tool for Python-based AI automation.

description:
  Hello and welcome to the Comma Agents community! We're absolutely delighted to have you here. Comma Agents is all about empowering coders like you to create and manage automated agents with ease and efficiency. Our platform is designed to make your journey into the world of automated language learning models (LLMs) both enjoyable and productive. Whether you're a seasoned developer or just starting out, we're here to support your creative coding endeavors every step of the way!



  Getting started with Comma Agents is a breeze! Here's how you can get everything set up:

  1. Open your terminal or command prompt.
  2. Run the following command:
     ```bash
     pip install comma-agents
     ```
  3. Voilà! You're all set to begin your adventure with Comma Agents.

  Head over to the documentation if you want to learn more about examples and docs [Comma Agents Documentation](https://commaagents.com/)



  Here's a simple script to kick things off with a local LLaMa model:

  ```python

  from comma_agents.hub.cloai.llama_cpp import LLaMaAgent


  example_agent = LLaMaAgent(
      name="Example Agent",
      llama_config={
          "model_path": "{local_model_path}",
      }
  )


  example_agent.call("Hello! How are you doing today LLM?")
  ```

  Want to type in the questions? Try a UserAgent with `require_input=True` and a sequential flow!

  ```python
  from comma_agents.agents import UserAgent
  from comma_agents.flows import SequentialFlow


  flow = SequentialFlow(
      flow_name="Example Flow",
      flows=[
          UserAgent(
              name="User",
              require_input=True
          ),
          example_agent
      ]
  )


  flow.run_flow()
  ```

  Head over to the full quick start guide to see how to continuously chat with your agent! [Comma Agents Documentation | Quick Start](https://commaagents.com/getting_started/quick_start)



  Comma Agents can be used in a myriad of exciting and innovative ways. Here are some of the cool things you can do:

  - **Automated Customer Support:** Enhance your customer service with bots that can understand and respond to queries in real-time.
  - **Content Creation:** Generate creative and unique content for blogs, social media, or even code!
  - **Data Analysis:** Automate the processing and interpretation of large datasets.
  - **Educational Tools:** Create interactive learning experiences for students in various subjects.
  - **Personal Assistants:** Develop your own digital assistant to help with daily tasks and reminders.



  The heart of our platform is the Comma Agents Hub, a central repository where you can discover a wide variety of pre-built agents and tools. It's like a treasure trove for automation enthusiasts! [Repo Link](https://github.com/CloAI/CommaAgentsHub) Here's what the Hub offers:

  - **Diverse Agents**: From language models to specialized AI tools, the Hub hosts a range of agents ready to be integrated into your projects.
  - **Ease of Access**: Easily fetch and deploy agents with simple import statements in your Python environment.
  - **Community Contributions**: Explore agents developed by our vibrant community, showcasing creativity and innovation.
  - **Regular Updates**: The Hub is continuously updated with the latest agents and tools, ensuring you have access to cutting-edge technology.



  To explore the Hub and start using its agents:

  ```python

  from comma_agents.hub.<hub_category>.<hub_username>.<module_name> import <AgentClass>


  my_agent = <AgentClass>(...)
  ```

  Replace `<hub_category| "agents", "flows", "strategies">`, `<hub_username>`, `<module_name>`, and `<AgentClass>` with the appropriate values from the Hub

  Find more details and contribute to the Hub here [Comma Agents Hub](https://github.com/CloAI/CommaAgentsHub)



  We love contributions! Whether you're fixing bugs, adding features, or improving documentation, your help makes Comma Agents better for everyone. Here’s how you can contribute:

  1. **Fork the Repository:** Create your own copy of our repository to make your changes.
  2. **Setup Your Environment:** Install the necessary dependencies and tools to start coding. The project uses [Poetry](https://python-poetry.org/) to manage dependencies for the project.
  ```bash
  poetry install
  ```
  3. **Make Your Changes:** Implement your brilliant ideas or fixes.
  4. **Submit a Pull Request:** Send us your changes for review.
  5. **Review & Merge:** We'll review your contribution and merge it into the main branch.

  Also, feel free to create issues and feature requests! Help Comma Agents support you and the ventures of automation with Agents!



  We're more than just a platform; we're a community! We encourage you to join our forums, participate in discussions, share your projects, and collaborate with fellow Comma Agents enthusiasts. Together, we can create something truly amazing.



  Ready to embark on this exciting journey with Comma Agents? We can't wait to see the incredible things you'll build. Dive in, explore, and let your creativity soar!

  Happy Coding! 🚀💻🤖


pkgId: 994c0e46a064ca7927316767ae14e0baffb9e167ee26e844c57e2355cc82f753
name: python-command-creator
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A package to simplify the creation of Python Command-Line tools
url: https://github.com/allRisc/command_creator
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-command-creator-1.2.0-1.src.rpm
checksum_type: sha256
description:
  A python package which simplifies the command creation process

  [![Tests](https://github.com/allRisc/command_creator/actions/workflows/test.yml/badge.svg)](https://github.com/allRisc/command_creator/actions/workflows/test.yml)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/command_creator.svg)](https://pypi.org/project/command_creator/)
  [![docs](https://readthedocs.org/projects/command-creator/badge)](https://command-creator.readthedocs.io/en/latest/index.html)

  See [Read-The-Docs](https://command-creator.readthedocs.io/en/latest/index.html) for details

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999  Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  [This is the first released version of the Lesser GPL.  It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it.  You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.  When we speak of free software, we are referring to freedom of use, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.  To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights.  These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.  For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you.  You must make sure that they, too, receive or can get the source code.  If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it.  And you must show them these terms so they know their rights.  We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.  To protect each distributor, we want to make it very clear that there is no warranty for the free library.  Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.  Finally, software patents pose a constant threat to the existence of any free program.  We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder.  Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.  Most GNU software, including some libraries, is covered by the ordinary GNU General Public License.  This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License.  We use this license for certain libraries in order to permit linking those libraries into non-free programs.  When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library.  The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom.  The Lesser General Public License permits more lax criteria for linking other code with the library.  We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License.  It also provides other free software developers Less of an advantage over competing non-free programs.  These disadvantages are the reason we use the ordinary General Public License for many libraries.  However, the Lesser license provides advantages in certain special circumstances.  For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard.  To achieve this, non-free programs must be allowed to use the library.  A more frequent case is that a free library does the same job as widely used non-free libraries.  In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.  In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software.  For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.  Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.  The precise terms and conditions for copying, distribution and modification follow.  Pay close attention to the difference between a "work based on the library" and a "work that uses the library".  The former contains code derived from the library, whereas the latter must be combined with the library in order to run.  GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you".  A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.  The "Library", below, refers to any such software library or work which has been distributed under these terms.  A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  "Source code" for a work means the preferred form of the work for making modifications to it.  For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it).  Whether that is true depends on what the Library does and what the program that uses the Library does.  1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) The modified work must itself be a software library.  b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.  c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.  d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.  (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application.  Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.  In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library.  To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License.  (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.)  Do not make any other change in these notices.  Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.  This option is useful when you wish to copy part of the code of the Library into a program that is not a library.  4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.  If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.  5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library".  Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.  However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library".  The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.  When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library.  The threshold for this to be true is not precisely defined by law.  If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work.  (Executables containing this object code plus portions of the Library will still fall under Section 6.)  Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.  6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.  You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License.  You must supply a copy of this License.  If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License.  Also, you must do one of these things:  a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library.  (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)  b) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.  c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.  d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.  e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.  For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it.  However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system.  Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.  7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities.  This must be distributed under the terms of the Sections above.  b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License.  However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  9. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Library or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.  10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.  11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all.  For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.  14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Libraries  If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change.  You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).  To apply these terms, attach the following notices to the library.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the library's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker.  <signature of Ty Coon>, 1 April 1990 Ty Coon, President of Vice  That's all there is to it!


pkgId: ea417b733d9e4cd1266d15d8340b91f354811dbe761203f962acfa57d35b50d7
name: python-command-runner
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Platform agnostic command and shell execution tool, also allows UAC/sudo privilege elevation
url: https://github.com/netinvent/command_runner
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-command-runner-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Percentage of issues still open](http://isitmaintained.com/badge/open/netinvent/command_runner.svg)](http://isitmaintained.com/project/netinvent/command_runner "Percentage of issues still open")
  [![Maintainability](https://api.codeclimate.com/v1/badges/defbe10a354d3705f287/maintainability)](https://codeclimate.com/github/netinvent/command_runner/maintainability)
  [![codecov](https://codecov.io/gh/netinvent/command_runner/branch/master/graph/badge.svg?token=rXqlphOzMh)](https://codecov.io/gh/netinvent/command_runner)
  [![linux-tests](https://github.com/netinvent/command_runner/actions/workflows/linux.yaml/badge.svg)](https://github.com/netinvent/command_runner/actions/workflows/linux.yaml)
  [![windows-tests](https://github.com/netinvent/command_runner/actions/workflows/windows.yaml/badge.svg)](https://github.com/netinvent/command_runner/actions/workflows/windows.yaml)
  [![GitHub Release](https://img.shields.io/github/release/netinvent/command_runner.svg?label=Latest)](https://github.com/netinvent/command_runner/releases/latest)


  command_runner's purpose is to run external commands from python, just like subprocess on which it relies,
  while solving various problems a developer may face among:
     - Handling of all possible subprocess.popen / subprocess.check_output scenarios / python versions in one handy function without encoding / timeout hassle
     - Allow stdout/stderr stream output to be redirected to callback functions / output queues / files so you get to handle output in your application while commands are running
     - Callback to optional stop check so we can stop execution from outside command_runner
     - Callback with optional process information so we get to control the process from outside command_runner
     - Callback once we're finished to easen thread usage
     - Optional process priority and io_priority settings
     - System agnostic functionality, the developer shouldn't carry the burden of Windows & Linux differences
     - Optional Windows UAC elevation module compatible with CPython, PyInstaller & Nuitka
     - Optional Linux sudo elevation compatible with CPython, PyInstaller & Nuitka
     - Optional heartbeat for command execution

  It is compatible with Python 2.7+, tested up to Python 3.12 (backports some newer functionality to Python 3.5) and is tested on both Linux and Windows.
  It is also compatible with PyPy Python implementation.
  ...and yes, keeping Python 2.7 compatibility has proven to be quite challenging.



  command_runner is a replacement package for subprocess.popen and subprocess.check_output
  The main promise command_runner can do is to make sure to never have a blocking command, and always get results.

  It works as wrapper for subprocess.popen and subprocess.communicate that solves:
     - Platform differences
        - Handle timeouts even for windows GUI applications that don't return anything to stdout
     - Python language version differences
        - Handle timeouts even on earlier Python implementations
        - Handle encoding even on earlier Python implementations
     - Keep the promise to always return an exit code (so we don't have to deal with exit codes and exception logic at the same time)
     - Keep the promise to always return the command output regardless of the execution state (even with timeouts, callback interrupts and keyboard interrupts)
     - Can show command output on the fly without waiting the end of execution (with `live_output=True` argument)
     - Can give command output on the fly to application by using queues or callback functions
     - Catch all possible exceptions and log them properly with encoding fixes
     - Be compatible, and always return the same result regarless of platform

  command_runner also promises to properly kill commands when timeouts are reached, including spawned subprocesses of such commands.
  This specific behavior is achieved via psutil module, which is an optional dependency.




  Install with `pip install command_runner`

  The following example will work regardless of the host OS and the Python version.

  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('ping 127.0.0.1', timeout=10)
  ```






  `pip install command_runner` or download the latest git release







  In order to keep the promise to always provide an exit_code, spcial exit codes have been added for the case where none is given.
  Those exit codes are:

  - -250 : command_runner called with incompatible arguments
  - -251 : stop_on function returned True
  - -252 : KeyboardInterrupt
  - -253 : FileNotFoundError, OSError, IOError
  - -254 : Timeout
  - -255 : Any other uncatched exceptions

  This allows you to use the standard exit code logic, without having to deal with various exceptions.



  command_runner has an `encoding` argument which defaults to `utf-8` for Unixes and `cp437` for Windows platforms.
  Using `cp437` ensures that most `cmd.exe` output is encoded properly, including accents and special characters, on most locale systems.
  Still you can specify your own encoding for other usages, like Powershell where `unicode_escape` is preferred.

  ```python
  from command_runner import command_runner

  command = r'C:\Windows\sysnative\WindowsPowerShell\v1.0\powershell.exe --help'
  exit_code, output = command_runner(command, encoding='unicode_escape')
  ```

  Earlier subprocess.popen implementations didn't have an encoding setting so command_runner will deal with encoding for those.
  You can also disable command_runner's internal encoding in order to get raw process output (bytes) by passing False boolean.

  Example:
  ```python
  from command_runner import command_runner

  exit_code, raw_output = command_runner('ping 127.0.0.1', encoding=False)
  ```



  **Note: for live output capture and threading, see stream redirection. If you want to run your application while command_runner gives back command output, the best way to go is queues / callbacks.**

  command_runner can output a command output on the fly to stdout, eg show output on screen during execution.
  This is helpful when the command is long, and we need to know the output while execution is ongoing.
  It is also helpful in order to catch partial command output when timeout is reached or a CTRL+C signal is received.
  Example:

  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('ping 127.0.0.1', shell=True, live_output=True)
  ```

  Note: using live output relies on stdout pipe polling, which has lightly higher cpu usage.



  **command_runner has a `timeout` argument which defaults to 3600 seconds.**
  This default setting ensures commands will not block the main script execution.
  Feel free to lower / higher that setting with `timeout` argument.
  Note that a command_runner kills the whole process tree that the command may have generated, even under Windows.

  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('ping 127.0.0.1', timeout=30)
  ```



  Using `shell=True` will spawn a shell which will spawn the desired child process.
  Be aware that under MS Windows, no direct process tree is available.
  We fixed this by walking processes during runtime. The drawback is that orphaned processes cannot be identified this way.




  `command_runner` has it's own logging system, which will log all sorts of error logs.
  If you need to disable it's logging, just run with argument silent.
  Be aware that logging.DEBUG log levels won't be silenced, by design.

  Example:
  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('ping 127.0.0.1', silent=True)
  ```

  If you also need to disable logging.DEBUG level, you can run the following code which will required logging.CRITICAL only messages which `command_runner` never does:

  ```python
  import logging
  import command_runner

  logging.getLogger('command_runner').setLevel(logging.CRITICAL)
  ```



  `command_runner` allows two different process output capture methods:

  `method='monitor'` which is default:
   - A thread is spawned in order to check stop conditions and kill process if needed
   - A main loop waits for the process to finish, then uses proc.communicate() to get it's output
   - Pros:
       - less CPU usage
       - less threads
   - Cons:
       - cannot read partial output on KeyboardInterrupt or stop_on (still works for partial timeout output)
       - cannot use queues or callback functions redirectors
       - is 0.1 seconds slower than poller method


  `method='poller'`:
   - A thread is spawned and reads stdout/stderr pipes into output queues
   - A poller loop reads from the output queues, checks stop conditions and kills process if needed
   - Pros:
        - Reads on the fly, allowing interactive commands (is also used with `live_output=True`)
        - Allows stdout/stderr output to be written live to callback functions, queues or files (useful when threaded)
        - is 0.1 seconds faster than monitor method, is preferred method for fast batch runnings
   - Cons:
        - lightly higher CPU usage

  Example:
  ```python
  from command_runner import command_runner


  exit_code, output = command_runner('ping 127.0.0.1', method='poller')
  exit_code, output = command_runner('ping 127.0.0.1', method='monitor')
  ```



  `command_runner` allows to redirect some stream directly into the subprocess it spawns.

  Example code
  ```python
  import sys
  from command_runner import command_runner


  exit_code, output = command_runner("gzip -d", stdin=sys.stdin.buffer)
  print("Uncompressed data", output)
  ```
  The above program, when run with `echo "Hello, World!" | gzip | python myscript.py` will show the uncompressed  string `Hello, World!`

  You can use whatever file descriptor you want, basic ones being sys.stdin for text input and sys.stdin.buffer for binary input.



  command_runner can redirect stdout and/or stderr streams to different outputs:
   - subprocess pipes
   - /dev/null or NUL
   - files
   - queues
   - callback functions

  Unless an output redirector is given for `stderr` argument, stderr will be redirected to `stdout` stream.
  Note that both queues and callback function redirectors require `poller` method and will fail if method is not set.

  Possible output redirection options are:

  - subprocess pipes

  By default, stdout writes into a subprocess.PIPE which is read by command_runner and returned as `output` variable.
  You may also pass any other subprocess.PIPE int values to `stdout` or `stderr` arguments.

  - /dev/null or NUL

  If `stdout=False` and/or `stderr=False` argument(s) are given, command output will not be saved.
  stdout/stderr streams will be redirected to `/dev/null` or `NUL` depending on platform.

  Output will always be `None`. See `split_streams` for more details using multiple outputs.

  - files

  Giving `stdout` and/or `stderr` arguments a string, `command_runner` will consider the string to be a file path where stream output will be written live.

  Examples:
  ```python
  from command_runner import command_runner
  exit_code, output = command_runner('dir', stdout=r"C:/tmp/command_result", stderr=r"C:/tmp/command_error", shell=True)
  ```
  ```python
  from command_runner import command_runner
  exit_code, output = command_runner('dir', stdout='/tmp/stdout.log', stderr='/tmp/stderr.log', shell=True)
  ```

  Opening a file with the wrong encoding (especially opening a CP437 encoded file on Windows with UTF-8 coded might endup with UnicodedecodeError.)

  - queues

  Queue(s) will be filled up by command_runner.

  In order to keep your program "live", we'll use the threaded version of command_runner which is basically the same except it returns a future result instead of a tuple.

  Note: With all the best will, there's no good way to achieve this under Python 2.7 without using more queues, so the threaded version is only compatible with Python 3.3+.

  For Python 2.7, you must create your thread and queue reader yourself (see footnote for a Python 2.7 comaptible example).

  Threaded command_runner plus queue example:

  ```python
  import queue
  from command_runner import command_runner_threaded

  output_queue = queue.Queue()
  stream_output = ""
  thread_result = command_runner_threaded('ping 127.0.0.1', shell=True, method='poller', stdout=output_queue)

  read_queue = True
  while read_queue:
      try:
          line = output_queue.get(timeout=0.1)
      except queue.Empty:
          pass
      else:
          if line is None:
              read_queue = False
          else:
              stream_output += line
              


  exit_code, output = thread_result.result()
  ```
  You might also want to read both stdout and stderr queues. In that case, you can create a read loop just like in the following example.
  Here we're reading both queues in one loop, so we need to observe a couple of conditions before stopping the loop, in order to catch all queue output:
  ```python
  import queue
  from time import sleep
  from command_runner import command_runner_threaded

  stdout_queue = queue.Queue()
  stderr_queue = queue.Queue()
  thread_result = command_runner_threaded('ping 127.0.0.1', method='poller', shell=True, stdout=stdout_queue, stderr=stderr_queue)

  read_stdout = read_stderr = True
  while read_stdout or read_stderr:

      try:
          stdout_line = stdout_queue.get(timeout=0.1)
      except queue.Empty:
          pass
      else:
          if stdout_line is None:
              read_stdout = False
          else:
              print('STDOUT:', stdout_line)

      try:
          stderr_line = stderr_queue.get(timeout=0.1)
      except queue.Empty:
          pass
      else:
          if stderr_line is None:
              read_stderr = False
          else:
              print('STDERR:', stderr_line)

      

  exit_code, output = thread_result.result()
  assert exit_code == 0, 'We did not succeed in running the thread'

  ```

  - callback functions

  The callback function will get one argument, being a str of current stream readings.
  It will be executed on every line that comes from streams.
  Example:
  ```python
  from command_runner import command_runner

  def callback_function(string):
      
      print('CALLBACK GOT:', string)


  exit_code, output = command_runner('ping 127.0.0.1', stdout=callback_function, method='poller')
  ```



  In some situations, you want a command to be aborted on some external triggers.
  That's where `stop_on` argument comes in handy.
  Just pass a function to `stop_on`, as soon as function result becomes True, execution will halt with exit code -251.

  Example:
  ```python
  from command_runner import command_runner

  def some_function():
      return True if we_must_stop_execution
  exit_code, output = command_runner('ping 127.0.0.1', stop_on=some_function)
  ```



  By default, command_runner checks timeouts and outputs every 0.05 seconds.
  You can increase/decrease this setting via `check_interval` setting which accepts floats.
  Example: `command_runner(cmd, check_interval=0.2)`
  Note that lowering `check_interval` will increase CPU usage.



  `command_runner` can provide a subprocess.Popen instance of currently run process as external data.
  In order to do so, just declare a function and give it as `process_callback` argument.

  Example:
  ```python
  from command_runner import command_runner

  def show_process_info(process):
      print('My process has pid: {}'.format(process.pid))

  exit_code, output = command_runner('ping 127.0.0.1', process_callback=show_process_info)
  ```



  By default, `command_runner` returns a tuple like `(exit_code, output)` in which output contains both stdout and stderr stream outputs.
  You can alter that behavior by using argument `split_stream=True`.
  In that case, `command_runner` will return a tuple like `(exit_code, stdout, stderr)`.

  Example:
  ```python
  from command_runner import command_runner

  exit_code, stdout, stderr = command_runner('ping 127.0.0.1', split_streams=True)
  print('exit code:', exit_code)
  print('stdout', stdout)
  print('stderr', stderr)
  ```



  `command_runner` allows to execute a callback function once it has finished it's execution.
  This might help building threaded programs where a callback is needed to disable GUI elements for example.

  Example:
  ```python
  from command_runner import command_runner

  def do_something():
      print("We're done running")

  exit_code, output = command_runner('ping 127.0.0.1', on_exit=do_something)
  ```


  `command_runner` can set it's subprocess priority to 'low', 'normal' or 'high', which translate to 15, 0, -15 niceness on Linux and BELOW_NORMAL_PRIORITY_CLASS and HIGH_PRIORITY_CLASS in Windows.
  On Linux, you may also directly use priority with niceness int values.

  You may also set subprocess io priority to 'low', 'normal' or 'high'.

  Example:
  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('some_intensive_process', priority='low', io_priority='high')
  ```


  When running long commands, one might want to know that the program is still running.
  The following example will log a message every hour stating that we're still running our command

  ```python
  from command_runner import command_runner

  exit_code, output = command_runner('/some/long/command', timeout=None, heartbeat=3600)
  ```



  `command_runner` takes **any** argument that `subprocess.Popen()` would take.

  It also uses the following standard arguments:
   - command (str/list): The command, doesn't need to be a list, a simple string works
   - valid_exit_codes (list): List of exit codes which won't trigger error logs
   - timeout (int): seconds before a process tree is killed forcefully, defaults to 3600
   - shell (bool): Shall we use the cmd.exe or /usr/bin/env shell for command execution, defaults to False
   - encoding (str/bool): Which text encoding the command produces, defaults to cp437 under Windows and utf-8 under Linux
   - stdin (sys.stdin/int): Optional stdin file descriptor, sent to the process command_runner spawns
   - stdout (str/queue.Queue/function/False/None): Optional path to filename where to dump stdout, or queue where to write stdout, or callback function which is called when stdout has output
   - stderr (str/queue.Queue/function/False/None): Optional path to filename where to dump stderr, or queue where to write stderr, or callback function which is called when stderr has output
   - no_close_queues (bool): Normally, command_runner sends None to stdout / stderr queues when process is finished. This behavior can be disabled allowing to reuse those queues for other functions wrapping command_runner
   - windows_no_window (bool): Shall a command create a console window (MS Windows only), defaults to False
   - live_output (bool): Print output to stdout while executing command, defaults to False
   - method (str): Accepts 'poller' or 'monitor' stdout capture and timeout monitoring methods
   - check interval (float): Defaults to 0.05 seconds, which is the time between stream readings and timeout checks
   - stop_on (function): Optional function that when returns True stops command_runner execution
   - on_exit (function): Optional function that gets executed when command_runner has finished (callback function)
   - process_callback (function): Optional function that will take command_runner spawned process as argument, in order to deal with process info outside of command_runner
   - split_streams (bool): Split stdout and stderr into two separate results
   - silent (bool): Allows to disable command_runner's internal logs, except for logging.DEBUG levels which for obvious reasons should never be silenced
   - priority (str): Allows to set CPU bound process priority (takes 'low', 'normal' or 'high' parameter)
   - io_priority (str): Allows to set IO priority for process (takes 'low', 'normal' or 'high' parameter)
   - heartbeat (int): Optional seconds on which command runner should log a heartbeat message
   - close_fds (bool): Like Popen, defaults to True on Linux and False on Windows
   - universal_newlines (bool): Like Popen, defaults to False
   - creation_flags (int): Like Popen, defaults to 0
   - bufsize (int): Like Popen, defaults to 16384. Line buffering (bufsize=1) is deprecated since Python 3.7

  **Note that ALL other subprocess.Popen arguments are supported, since they are directly passed to subprocess.**




  command_runner package allowing privilege elevation.
  Becoming an admin is fairly easy with command_runner.elevate
  You only have to import the elevate module, and then launch your main function with the elevate function.



  ```python
  from command_runner.elevate import elevate

  def main():
      """My main function that should be elevated"""
      print("Who's the administrator, now ?")

  if __name__ == '__main__':
      elevate(main)
  ```

  elevate function handles arguments (positional and keyword arguments).
  `elevate(main, arg, arg2, kw=somearg)` will call `main(arg, arg2, kw=somearg)`





  The elevate module has a nifty is_admin() function that returns a boolean according to your current root/administrator privileges.
  Usage:

  ```python
  from command_runner.elevate import is_admin

  print('Am I an admin ? %s' % is_admin())
  ```



  Initially designed for Windows UAC, command_runner.elevate can also elevate privileges on Linux, using the sudo command.
  This is mainly designed for PyInstaller / Nuitka executables, as it's really not safe to allow automatic privilege elevation of a Python interpreter.

  Example for a binary in `/usr/local/bin/my_compiled_python_binary`

  You'll have to allow this file to be run with sudo without a password prompt.
  This can be achieved in `/etc/sudoers` file.

  Example for Redhat / Rocky Linux, where adding the following line will allow the elevation process to succeed without password:
  ```
  someuser ALL= NOPASSWD:/usr/local/bin/my_compiled_python_binary
  ```





  The following example is a Python 2.7 compatible threaded implementation that reads stdout / stderr queue in a thread.
  This only exists for compatibility reasons.

  ```python
  import queue
  import threading
  from command_runner import command_runner

  def read_queue(output_queue):
      """
      Read the queue as thread
      Our problem here is that the thread can live forever if we don't check a global value, which is...well ugly
      """
      stream_output = ""
      read_queue = True
      while read_queue:
          try:
              line = output_queue.get(timeout=1)
          except queue.Empty:
              pass
          else:
              
              if line is None:
                  read_queue = False
              else:
                  stream_output += line
                  



  output_queue = queue.Queue()


  read_thread = threading.Thread(
      target=read_queue, args=(output_queue)
  )
  read_thread.daemon = True  # thread dies with the program
  read_thread.start()


  exit_code, output = command_runner('ping 127.0.0.1', stdout=output_queue, method='poller')
  ```


pkgId: 61510da3a14a19323d126449cd3ee09326006e883b420211b0cb324846723c30
name: python-command-saver-terminal-program
arch: src
version: 2.2.2
epoch: 0
release: 1
url: https://pypi.org/project/command-saver-terminal-program/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-command-saver-terminal-program-2.2.2-1.src.rpm
checksum_type: sha256
summary:
  Simple terminal helper program to save long terminal commands. See git: https://github.com/Zzanetiite/CommandSaver

description:
  CommandSaver is a console-interface application that saves and executes terminal commands added by the user.


  The purpose of the program is to help the user keep track of commonly used complicated commands. It is a lot like aliases.


  Install the package in the user directory using:

  ```
  pip install --user command-saver-terminal-program
  ```

  Close the shell, start a new shell and use `cs` to run.



  This error happens when the script path hasn't been added to the user's directory. Check whether the installation directory is included in the user's PATH. If not, modify your shell configuration file (e.g., ~/.bashrc or ~/.zshrc) to include it. For example, you can add the following line to your ~/.zshrc file:

  ```
  export PATH=/local/home/username/.local/bin:$PATH
  ```


  Use `cs` to launch the program from bash or zsh.
  Or run a single command using `cs OPTION COMMAND_ID`



  Project has been developed using PyCharm integrated development environment (IDE) and in accordance with the design of Software Engineering Fundamentals final assignment (University assignment).


  Read more about rich package here: https://rich.readthedocs.io/en/stable/tables.html

  Read more about logger here: https://docs.python.org/3/library/logging.html

  Read more about mock objects used for unit tests here: https://docs.python.org/3/library/unittest.mock.html?highlight=patch#module-unittest.mock

  Additional details on the design and the project have been described in the Software Engineering Fundamentals final assignment.



  The code has a comment in almost every line, this was the coursework requirement.


  Unit tests have been called them in the terminal using python. Tests have not been updated for CommandSaver versions >2.0 (outdated from 1.0 - didn't have time to do them).


  Packaged using:
  ```
  pip install setuptools wheel
  ```

  ```
  python setup.py sdist bdist_wheel
  ```

  Distributed via PyPI using twine:
  ```
  pip install twine
  ```

  ```
  twine upload dist/*
  ```

  Locally tested using:
  ```
  pip install --user dist/command-saver-terminal-program-2.2.2.tar.gz
  ```


pkgId: 8f1029d5a07a9820a2cc29927ec7f50828711921f0a3bd67e9f1129108ba5e29
name: python-commandRunner
arch: src
version: 0.8.12
epoch: 0
release: 1
summary: Allows thread safe, object oriented running of commandline operations and blocks of code
url: https://github.com/AnalyticsAutomated/commandRunner.git
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commandRunner-0.8.12-1.src.rpm
checksum_type: sha256
description:
  commandRunner is yet another package created to handle running commands,
  scripts or programs on the command line targetted at thread safe execution
  for Celery. The simplest class lets you run anything locally on your machine.
  Other classes are targeted at Analytics and data processing platforms such as
  Grid Engine (and eventually HADOOP). The class attempts to run commands in a
  moderately threadsafe way by requiring that you provide it with sufficient
  information that it can build a uniquely labeled temporary directory for all
  input and output files. This means that this can play nicely with things like
  Celery workers.


pkgId: de890afb335a572e8cb24550dff82e23e0b8aeb2f01806f2cdaddb8f2110ce22
name: python-commandlib
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Pythonic command runner
url: https://github.com/crdoconnor/commandlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commandlib-0.3.5-1.src.rpm
checksum_type: sha256
description:
  CommandLib is a pythonic wrapper around subprocess that lets you pass around command objects
  and daisy-chain:
  * Arguments
  * Paths
  * Other environment variables
  * Runtime directory
  * Other runtime properties (run in shell, conceal stdout/stderr, ignore error codes, etc.)
  It is somewhat inspired by amoffat's sh, Kenneth Reitz's requests, jaraco's path.py
  and SQLAlchemy.
  To install:
      $ pip install commandlib
  Example:
      >>> from commandlib import Command
      >>> ls = Command("ls")
      >>> ls("-t").in_dir("/").with_shell().run()
      sys  tmp  run  dev  proc  etc  boot  sbin  root  vmlinuz  initrd.img  bin  lib  opt  vmlinuz.old  initrd.img.old  media  home  cdrom  lost+found  var  srv  usr  mnt
  CommandPath example:
      >>> from commandlib import CommandPath
      >>> bin = CommandPath("/bin")
      >>> bin.ls("-t").in_dir("/").run()
      sys  tmp  run  dev  proc  etc  boot  sbin  root  vmlinuz  initrd.img  bin  lib  opt  vmlinuz.old  initrd.img.old  media  home  cdrom  lost+found  var  srv  usr  mnt


pkgId: 34a682526f3d37f51132847e84e8b0e7f99b797205365c12a53d68ba859e34c0
name: python-commandparse
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: CLI application commands parser
url: https://github.com/flgy/commandparse
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commandparse-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Module to parse command based CLI application.

  Usage:

  * Subclass the Command class
  * Add a method with a name such as `prefix_commandname` with kwargs as required argument
  * Create an ArgumentParser instance
  * Call the `Subclass.add_suparsers` with the ArgumentParser instance and other settings
  * Use the `dispatch_command` function with the args returned by `parser.parse_args()`

  ```
  parser = ArgumentParser(...)
  [...]
  Subclass.add_subparsers(parser, prefixes=["get_", "do_", ...], title="commands", description="available commands")

  cmd = Subclass(...)
  cmd.dispatch_command(commands, args)
  ```

  See example.py for a more complete example. For a real world application using this lib, see: https://github.com/franc-pentest/ldeep


pkgId: 8a5c56e989aefa0d3dc3940db98f316016f5164d01fcd20e80f826dad896b8d5
name: python-commandrex-cli
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: A natural language interface for terminal commands
url: https://pypi.org/project/commandrex-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commandrex-cli-0.1.9-1.src.rpm
checksum_type: sha256
description:
  A natural language interface for terminal commands. Talk to your terminal in plain English!



  - 🗣️ Use natural language to run terminal commands
  - 🔍 Preview commands before execution
  - 🔒 Built-in safety checks for dangerous commands
  - 💻 Cross-platform support (Windows, Linux, macOS)
  - 📝 Command history with search
  - ⌨️ Arrow key navigation
  - 📊 Usage statistics



  ```bash
  pip install commandrex-cli
  ```



  - Python 3.9 or higher
  - OpenAI API key (get one at https://platform.openai.com)



  1. Install CommandRex:
  ```bash
  pip install commandrex-cli
  ```

  2. Run CommandRex:
  ```bash
  commandrex
  ```

  3. On first run, you'll be prompted to enter your OpenAI API key.

  4. Start typing commands in plain English:
  ```
  Show me all files in the current directory
  Create a new folder called projects
  What's my current directory
  ```

  5. Update-
  ```
  pip install --upgrade commandrex-cli
  ```



  - Use arrow keys (↑/↓) to navigate command history
  - Press Ctrl+R to search command history
  - Type 'help' for more information
  - Type 'history' to see command history
  - Type 'stats' to see usage statistics
  - Type 'exit' or 'quit' to leave



  Here are some example commands you can try:

  - "Show all files"
  - "Create a new folder called test"
  - "What's my IP address"
  - "Show system information"
  - "Create a file called notes.txt"



  - Commands are shown and explained before execution
  - Dangerous commands are flagged with warnings
  - Confirmation required before execution
  - Platform-specific command adaptation



  - `help` - Show help information
  - `history` - Show command history
  - `stats` - Show usage statistics
  - `clear` - Clear the screen
  - `reset-key` - Reset OpenAI API key
  - `exit` or `quit` - Exit CommandRex



  The OpenAI API key is stored securely using your system's keyring. You can:

  1. Set it via environment variable:
  ```bash
  export OPENAI_API_KEY=your-key-here
  ```

  2. Let CommandRex prompt you for it on first run

  3. Reset it anytime with:
  ```bash
  commandrex reset-key
  ```



  MIT License - see LICENSE file for details.


pkgId: 8fd974ee502d35c63e412a68f57843b36ade16ac9222a82bf0e86a41d10b2d59
name: python-comment-parser
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Parse comments from various source files.
url: http://github.com/jeanralphaviles/comment_parser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comment-parser-1.2.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/jeanralphaviles/comment_parser.svg?branch=master)](https://travis-ci.org/jeanralphaviles/comment_parser/branches)
  [![PyPI status](https://img.shields.io/pypi/status/comment_parser.svg)](https://pypi.python.org/pypi/comment_parser/)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/comment_parser.svg)](https://pypi.python.org/pypi/comment_parser/)
  [![PyPI license](https://img.shields.io/pypi/l/comment_parser.svg)](https://pypi.python.org/pypi/comment_parser/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/comment_parser.svg)](https://pypi.python.org/pypi/comment_parser/)

  Python module used to extract comments from source code files of various types.





  * libmagic



  ```shell
  sudo pip3 install comment_parser
  ```


  Additionally, complete the special installation requirements for
  [python-magic](https://github.com/ahupp/python-magic).



  To use, simply run:

  ```python
  >>> from comment_parser import comment_parser
  >>> # Returns a list of comment_parser.parsers.common.Comments
  >>> comment_parser.extract_comments('/path/to/source_file')
  >>> # Or
  >>> comment_parser.extract_comments_from_str('...')
  ```


  ```python
  def extract_comments(filename, mime=None):
      """Extracts and returns the comments from the given source file.

      Args:
          filename: String name of the file to extract comments from.
          mime: Optional MIME type for file (str). Note some MIME types accepted
              don't comply with RFC2045. If not given, an attempt to deduce the
              MIME type will occur.
      Returns:
          Python list of parsers.common.Comment in the order that they appear in
              the source file.
      Raises:
          UnsupportedError: If filename is of an unsupported MIME type.
      """
      pass


  def extract_comments_from_str(code, mime=None):
      """Extracts and returns comments from the given source string.

      Args:
          code: String containing code to extract comments from.
          mime: Optional MIME type for code (str). Note some MIME types accepted
              don't comply with RFC2045. If not given, an attempt to deduce the
              MIME type will occur.
      Returns:
          Python list of parsers.common.Comment in the order that they appear in
              the source code.
      Raises:
          UnsupportedError: If code is of an unsupported MIME type.
      """
      pass
  ```


  ```python
  class Comment(object):
      """Represents comments found in source files."""
      def text(self):
          """Returns the comment's text.
          Returns:
              String
          """
          pass

      def line_number(self):
          """Returns the line number the comment was found on.
          Returns:
              Int
          """
          pass

      def is_multiline(self):
          """Returns whether this comment was a multiline comment.
          Returns:
              True if comment was a multiline comment, False if not.
          """
         pass

      def __str__(self):
          pass

      def __eq__(self, other):
          pass
  ```





  Start python3 in the base of repository.

  ```python
  from comment_parser import comment_parser
  comment_parser.extract_comments('foo.c', mime='text/x-c')
  ```



  ```shell
  python3 setup.py test
  ```



  ```shell
  pylint comment_parser
  ```



  ```shell
  yapf -rip --style=yapf .
  ```



  ```shell
  python3 setup.py sdist
  twine upload dist/*
  ```



  | Language    | Mime String              |
  |------------ |------------------------- |
  | C           | text/x-c                 |
  | C++/C#      | text/x-c++               |
  | Go          | text/x-go                |
  | HTML        | text/html                |
  | Java        | text/x-java-source       |
  | Javascript  | application/javascript   |
  | Python      | text/x-python            |
  | Python      | text/x-script.python     |
  | Ruby        | text/x-ruby              |
  | Shell       | text/x-shellscript       |
  | XML         | text/xml                 |

  And more to come!

  *Check comment_parser.py for corresponding MIME types.*


pkgId: 3d075e8a44096318ca4c68f94dfda5f89f3935159706dfec558e79136f3f8dd3
name: python-commercecraft-utils
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A Python utility for translating CSV files between different languages using OpenAI's API
url: https://github.com/ehzSkhaS/commercecraft-utils
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commercecraft-utils-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python tool for translating CSV files between different languages.



  You can install the package in several ways:


  ```bash
  pip install commercecraft-utils
  ```


  1. Clone the repository:
  ```bash
  git clone https://github.com/ehzSkhaS/commercecraft-utils.git
  cd commercecraft-utils
  ```

  2. Install in development mode:
  ```bash
  pip install -e .
  ```



  Before using the translation utility, you need to set up your environment variables in a `.env` file. By default, the utility looks for this file in the root of your project, but you can specify a custom path when initializing the TranslationEngine:

  ```python

  translator = TranslationEngine()


  translator = TranslationEngine(dotenv_path='/path/to/your/.env')
  ```



  Create a `.env` file with the following variables:

  ```env

  OPENAI_API_KEY=your-api-key-here
  OPENAI_MODEL=gpt-3.5-turbo  # or gpt-4 for better translations
  MAX_TOKENS=2000
  TEMPERATURE=0.3
  BATCH_SIZE=10


  SET_SEPARATOR=,             # Separator for set fields (e.g., tags, categories)
  OUTPUT_SUFFIX=_translated   # Suffix added to translated files
  LANGUAGE_SEPARATOR=-        # Separator for language codes (e.g., en-US)
  FIELD_LANGUAGE_SEPARATOR=.  # Separator between field name and language (e.g., name.en-US)
  ```




  - `OPENAI_API_KEY`: Your OpenAI API key for authentication
  - `OPENAI_MODEL`: The model to use for translations
  - `MAX_TOKENS`: Maximum number of tokens per API call
  - `TEMPERATURE`: Controls randomness in translations (0.0-1.0)
  - `BATCH_SIZE`: Number of texts to translate in one batch


  - `SET_SEPARATOR`: Used to split and join set fields (e.g., "tag1,tag2,tag3")
  - `OUTPUT_SUFFIX`: Added to output files (e.g., "products.csv" → "products_translated.csv")
  - `LANGUAGE_SEPARATOR`: Used in language codes (e.g., "en-US", "es-ES")
  - `FIELD_LANGUAGE_SEPARATOR`: Separates field names from language codes in columns



  ```python
  import asyncio
  from commercecraft_utils import TranslationEngine

  PROD_PATH = 'data/products.csv'
  CAT_PATH = 'data/categories.csv'


  async def main():
  translator = TranslationEngine()

      
      print("Processing categories...")
      await translator.process_file(CAT_PATH, exclude_columns=['slug'])

      
      print("Processing products...")
      await translator.process_file(PROD_PATH, set_columns=['benefits', ],exclude_columns=['slug', 'recomendations'])


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

  ```



  Run the tests using:
  ```bash
  python -m pytest tests/
  ```



  This project is licensed under the MIT License - see the LICENSE file for details.



  A robust translation engine that handles translation of values, dataframes, and files. Supports batch processing, content protection, and multiple language pairs.



  Main class for handling translation of dataframes and files with support for various content types.



  ```python
  def __init__(self, dotenv_path: str = None, source_lang: str = 'en-US')
  ```

  **Arguments:**
  - `dotenv_path` (str, optional): Path to the .env file. Defaults to None.
  - `source_lang` (str, optional): Source language code. Defaults to 'en-US'.

  **Required Environment Variables:**
  - `SET_SEPARATOR`: Separator for set fields
  - `OUTPUT_SUFFIX`: Suffix for output files
  - `LANGUAGE_SEPARATOR`: Separator for language codes
  - `FIELD_LANGUAGE_SEPARATOR`: Separator for field language codes




  ```python
  async def translate_values(self, values: list[str], source_lang: str, target_lang: str) -> list[str]
  ```
  Translate a list of values using the translation service.

  **Arguments:**
  - `values` (list[str]): List of strings to translate
  - `source_lang` (str): Source language code
  - `target_lang` (str): Target language code

  **Returns:**
  - list[str]: List of translated strings


  ```python
  async def translate_dataframe(self, df: pd.DataFrame, set_columns: list[str] = None, exclude_columns: list[str] = None) -> pd.DataFrame
  ```
  Translate a dataframe using the translation service. Handles both regular fields and set fields (comma-separated values).

  - `set_columns`: List of columns containing comma-separated values that need to be translated individually
  - `exclude_columns`: List of columns to exclude from translation

  **Arguments:**
  - `df` (pd.DataFrame): Input dataframe
  - `set_columns` (list[str], optional): Columns to treat as sets. Defaults to None.
  - `exclude_columns` (list[str], optional): Columns to exclude from translation. Defaults to None.

  **Returns:**
  - pd.DataFrame: Translated dataframe


  ```python
  async def process_file(self, input_path: str, output_path: str = None, set_columns: list[str] = None, exclude_columns: list[str] = None) -> None
  ```
  Process a CSV file and save the translated version. If no output path is provided, appends the OUTPUT_SUFFIX to the input filename.

  **Arguments:**
  - `input_path` (str): Path to input CSV file
  - `output_path` (str, optional): Path to output CSV file. Defaults to None.
  - `set_columns` (list[str], optional): Columns to treat as sets. Defaults to None.
  - `exclude_columns` (list[str], optional): Columns to exclude from translation. Defaults to None.



  Handles communication with the OpenAI API for text translation. Supports batch processing and retries.



  Handles communication with the OpenAI API for text translation.



  ```python
  def __init__(self, dotenv_path: str = None)
  ```

  **Arguments:**
  - `dotenv_path` (str, optional): Path to the .env file. Defaults to None.

  **Required Environment Variables:**
  - `OPENAI_API_KEY`: OpenAI API key
  - `OPENAI_MODEL`: OpenAI model to use
  - `MAX_TOKENS`: Maximum tokens for API calls
  - `TEMPERATURE`: Temperature for API calls
  - `BATCH_SIZE`: Number of texts to translate in one batch




  ```python
  async def translate_texts(self, texts: list[str], source_lang: str, target_lang: str) -> list[str]
  ```
  Translates a list of texts in batches. Handles rate limiting between batches.

  **Arguments:**
  - `texts` (list[str]): List of texts to translate
  - `source_lang` (str): Source language code
  - `target_lang` (str): Target language code

  **Returns:**
  - list[str]: List of translated texts


  ```python
  async def translate_batch(self, texts: list[str], source_lang: str, target_lang: str, max_retries: int = 3) -> list[str]
  ```
  Translate a batch of texts with retry mechanism.

  **Arguments:**
  - `texts` (list[str]): List of texts to translate
  - `source_lang` (str): Source language code
  - `target_lang` (str): Target language code
  - `max_retries` (int, optional): Maximum number of retries. Defaults to 3.

  **Returns:**
  - list[str]: List of translated texts



  Protects special content during translation to ensure it remains intact.



  Handles preprocessing of text before translation to protect special content.



  ```python
  def __init__(self)
  ```

  Initializes preprocessor with HTML, JSON, Measurement, and Table protectors.




  ```python
  def preprocess(self, text: str) -> str
  ```
  Preprocess text by protecting all special content.

  **Arguments:**
  - `text` (str): Text to preprocess

  **Returns:**
  - str: Preprocessed text with protected content


  ```python
  def postprocess(self, text: str) -> str
  ```
  Restore all protected content after translation.

  **Arguments:**
  - `text` (str): Text to postprocess

  **Returns:**
  - str: Original text with restored content




  ```python
  def get_base_columns(columns: list[str], fls: str = '.') -> set[str]
  ```
  Extract base column names without language suffix.

  **Arguments:**
  - `columns` (list[str]): List of column names
  - `fls` (str, optional): Field language separator. Defaults to '.'.

  **Returns:**
  - set[str]: Set of base column names


  ```python
  def get_language_columns(df: pd.DataFrame, base_name: str, fls: str = '.') -> dict[str, str]
  ```
  Get all language variations of a column.

  **Arguments:**
  - `df` (pd.DataFrame): Input dataframe
  - `base_name` (str): Base column name
  - `fls` (str, optional): Field language separator. Defaults to '.'.

  **Returns:**
  - dict[str, str]: Dictionary mapping language codes to column names

rpm_license:
  MIT License  Copyright (c) 2024 CSV Translator  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: 75b3e7606c1a30c2e139122a5bf7865903e9e8b275a8bec9c9b8dbce27b79e40
name: python-commercetools
arch: src
version: 2023.6.29
epoch: 0
release: 1
summary: SDK for Commercetools
url: https://github.com/labd/commercetools-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commercetools-2023.6.29-1.src.rpm
checksum_type: sha256
description:
  This is an unofficial Python SDK for the Commercetools platform. It only
  supports Python 3.6+ and uses type annotation for an improved development
  experience.
  The API is generated using the commercetools api RAML file and uses
  marshmallow for the serialization and deserialization.


pkgId: 8fe533dc8de7c749418cdc6213300dffc8843e57430bf31faca9387c93dc73c7
name: python-commit-critic
arch: src
version: 0.1
epoch: 0
release: 1
summary: Command line tool for generating code review prompts using the Metaphor format
url: https://github.com/m6r-ai/commit-critic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commit-critic-0.1-1.src.rpm
checksum_type: sha256
description:
  commit-critic is an extensible Python-based command-line application that helps developers get AI-powered code reviews.
  It takes your source code files and review guidelines as input, then generates a detailed prompt that can be used with
  you favourite AI to perform detailed code reviews.

  The code reviewing guidelines are described by a series of files written in "Metaphor", a structured natural language
  format designed to generate structured prompts for LLMs.

  While the application is a demonstration of using Metaphor and the m6rclib parser/prompt compiler, commit-critic
  was itself coded by an AI, based on a metaphor description.

  For more detail you can read how this was designed and built at
  [https://m6r.ai/blog/000005-commit-critic](https://m6r.ai/blog/000005-commit-critic).



  - Process multiple source files for review
  - Support for custom review guidelines using Metaphor (.m6r) files
  - Flexible search paths for finding guideline files
  - Output to file or stdout
  - Comprehensive error handling and reporting



  The application requires Python 3 and the m6rclib package. Ensure both are installed before using the tool.

  Install m6rclib:
  ```bash
  pip install m6rclib
  ```

  To install the `commit-critic` command:
  ```bash
  pip install .
  ```



  Basic syntax:
  ```bash
  commit-critic [options] file1 [file2 ...]
  ```



  - `-h, --help`: Show help message and exit
  - `-v, --version`: Show program's version number and exit
  - `-o OUTPUT, --output OUTPUT`: Specify output file (defaults to stdout)
  - `-g PATH, --guideline-path PATH`: Add a directory to search for .m6r review guideline files (defaults to current directory)



  The environment variable `COMMIT_CRITIC_GUIDELINE_DIR` can also be used to specify the directory, or directories, to search for .m6r review guidelines files.



  Review a single file using guidelines in the current directory (or the `COMMIT_CRITIC_GUIDELINE_DIR):
  ```bash
  commit-critic src/myfile.py
  ```

  Review multiple files and save the prompt to a file:
  ```bash
  commit-critic -o review-prompt.txt src/file1.py src/file2.py
  ```

  Use guidelines from multiple directories:
  ```bash
  commit-critic -g ./guidelines -g ./custom-guidelines src/myfile.py
  ```



  The tool searches for Metaphor guideline files (*.m6r) in:
  1. The current working directory (default)
  2. Any directories specified with the `-g` option
  3. Any directories specified with the `COMMIT_CRITIC_GUIDELINE_DIR` environment variable

  At least one valid guideline file must be found for the tool to work.

  The tool will include all guidelines it can find.  If you want to add new ones for a particular language then
  create a new file for that language and add content in the same format as the examples provides.

  There are example guidelines in the git repo for the tool.  Please see the `review-guides` directory.



  The application uses the following exit codes:
  - 0: Success
  - 1: Command line usage error
  - 2: Data format error (e.g., invalid Metaphor syntax)
  - 3: Cannot open input file
  - 4: Cannot create output file



  The tool provides detailed error messages when issues occur:
  - Missing input files
  - Invalid command line arguments
  - Missing guideline files
  - Syntax errors in Metaphor files
  - File access problems

  Error messages are written to stderr and include:
  - Clear description of the error
  - Filename (when relevant)
  - Line number and column (for syntax errors)



  The tool generates a structured prompt using the Metaphor language format, which includes:
  1. A role definition for the AI reviewer
  2. Review guidelines from .m6r files
  3. The files to be reviewed
  4. Specific instructions for the review process

  The output can be directed to:
  - stdout (default)
  - A file specified with the `-o` option



  - The tool requires at least one .m6r guideline file to be present
  - Input files must be text-based source code files
  - Large files may need to be reviewed in segments



  Common issues and solutions:

  1. "No .m6r guideline files found":
     - Check that guideline files exist in the search paths
     - Verify file extensions are correctly set to .m6r
     - Use -g to specify additional search paths

  2. "Cannot open input file":
     - Verify the file exists
     - Check file permissions
     - Ensure the path is correct

  3. "Cannot create output file":
     - Check write permissions in the target directory
     - Verify the path is valid
     - Ensure sufficient disk space



  For more information or to report issues, please refer to the project's documentation or issue tracker.


pkgId: 1afcdc203d60f56e63ad7a51a28654430005eb465e0bd6510c7afb3c31fdbec2
name: python-commit-entropy
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: UNKNOWN
url: UNKNOWN
rpm_license: apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commit-entropy-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Commit Entropy is a tool that can be used to calculate the entropy of
  changes in a source code repository. Entropy for code changes is a
  measure of how specific each commit was in relation to the entire code
  base. Very specific commits only affect a small set of files, and thus
  have a low entropy. Commits that touch a large number of files are much
  less specific and have a higher entropy as a result.
  The term Entropy in this context is a simplified application of `Shannon
  Entropy <https://en.wikipedia.org/wiki/Entropy_%28information_theory%29>`__
  to commits in a source repository. It's simplified since we only look at
  the number of files changed each commit, with each file having an equal
  probability.
  Read more about entropy on our
  `blog <http://grip.qa/blog/entropy-measuring-software-maturity/>`__.


pkgId: f3ca3ac6182abe429c120d6c97216a949cb06ac302152d9e0db86ccccc2a5e4c
name: python-commit-linter
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/Hoopher/commit-linter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commit-linter-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  simple git hooks scripts for a better git experience that enforces you to use the known commit messages conventions

description:
  ![pypi](https://img.shields.io/pypi/v/commit-linter.svg)
  ![python](https://img.shields.io/pypi/pyversions/commit-linter.svg)
  ![license](https://img.shields.io/github/license/Hoopher/commit-linter.svg)
  ![last-commit](https://img.shields.io/github/last-commit/Hoopher/commit-linter.svg)
  ![downloads](https://img.shields.io/pypi/dm/commit-linter?style=flat-square)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/commit-linter)
  ![PyPI - Implementation](https://img.shields.io/pypi/implementation/commit-linter)
  ![PyPI - Format](https://img.shields.io/pypi/format/commit-linter)
  [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)





  commit-linter is a Python tool that helps you standardize your commit messages to a known [commit conventions](https://www.conventionalcommits.org/en/). the tool also add emojies to your commits.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install commit-linter.

  ```sh
  pip install commit-linter
  ```



  in your git repository just execute

  ```sh
  commit-linter
  ```
  or
  ```sh
  commit-linter install
  ```
  if you want to remove the hook, just execute
  ```sh
  commit-linter remove
  ```



  commit-linter uses git-hooks which are scripts that exists in each repository.
  Take a look at any repo you have, you will have `.git` directory, and inside you
  will find `hooks` directory, commit-linter just puts a simple script named `commit-msg`
  inside that  directory and makes it executable so each time you right a commit message
  it will get linted as per the conventions, you can look at script in your repository
  inside `.git/hooks` path.

  Read more about [Git Hooks](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks).


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.



  This Tool is Under [MIT](https://choosealicense.com/licenses/mit/) License.


pkgId: 629aee65a72d0b409fc1928c18b9ea71cbc0cb343ca99b585331ce1f2f9b2074
name: python-commit-text-organizer
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A Text Processor Targeted at Organizing Commit Messages.
url: https://github.com/DK96-OS/cto
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commit-text-organizer-1.1.2-1.src.rpm
checksum_type: sha256
description:
  A Text Processor targeted at organizing Commit Messages.

  Do you like to organize your commit messages? __CTO does!__ CTO operates on commit messages structured in a simple readable format.

  The input messages are cleaned up, condensed, and sorted alphabetically before being returned.


  FOCI is inspired by the following statement:

  ___A Commit may change many files, but it has just one purpose.___

  <details>
  <summary>FOCI Concepts</summary>

  - __Headers__
    - Signify the start of a commit message group
    - Make it easier to categorize and locate related changes
  - __Commit Lines__
    - Lines grouped together under each header
    - Detail changes to files or groups of files
    - Enhancing traceability and readability
  - __Subjects__
    - The start of a Commit Line
    - Indicating the file or group of files
    - Allowing for quick identification of affected areas
  - __Content Details__
    - The end of a Commit Line
    - Comma separated list of text describing specific changes
    - Providing clarity on the nature of the modification.
  </details>

  CTO and FOCI ensure that commit messages are well-organized and convey the intended changes in a clear, concise manner. This is key to making revision history easy to revisit.


  At a high level, messages are organized into groups.

  <details>
  <summary>Each group has a unique header name.</summary>


  Structure your commits using your own set of headers, such as:
  - Database Migration 32
  - Database Integration
  - Test Database Migrations

  When writing commits, ensure that you add a colon (:) immediately after the header name.

  Then, the lines immediately below the header are included in that group. These are called Commit Lines.
  </details>
  <details>
  <summary>A Commit Line starts with a subject, corresponding to a file, or group of files.</summary>


  A Subject is the start of a Commit Line in a header Group. It will usually describe a change in a single file, but you can group files into the subject.


  Lines in the same Header Group can be merged, but only if the subjects match.

  When Content details are merged, they are separated from the Subject, sorted alphabetically, and joined with a comma-space separator.


  The subject is separated from content details by one of these separators: (+) or (-).

  If a separator appears more than once in a Commit Line, it is ignored.
  </details>

  <details>
  <summary>A subject may include a verb, such as "Update", which can be replaced with a prefix shortcut.</summary>


  To reduce typing the same word for so many file changes (such as "Update", or "Create"), CTO includes a Line Prefix recognition and replacement feature.

       cto/text/commit_line_prefixes.py

  It recognizes prefixes (that you can change) and replaces them with the most commonly used words.


  | Shortcut | Prefix |
  |----------|--------|
  | c | Create |
  | d | Delete |
  | f | Fix |
  | m | Move |
  | r | Remove |
  | t | Test |
  | u | Update |
  | cr | Create |
  | del | Delete |
  | mv | Move |
  | up | Update |
  </details>


  - A header ends with a colon ":"
  - A blank line will start a new group
  - Commit Lines start with the star (*)
  - Subject is separated from content by (+) or (-)
  - Content may contain multiple changes that are comma-separated


  By default, your squashed PR message will have groups organized alphabetically by their header names.
  - Subjects within each group are sorted alphabetically
  - Sorting is done after applying Commit Line Prefix Shortcuts.


  __Input:__
  ```
  Header 1:
  *u File.c - new method hello_world()
  *u File.c - new method foo()

  Header 2:
  *c NewFile.c

  Header 2:
  *r OldFile.c
  ```
  __Output:__
  ```
  Header 1:
  * Update File.c - new method hello_world(), new method foo()

  Header 2:
  * Create NewFile.c
  * Remove OldFile.c
  ```


  0. __Install__: Use `python -m pip install commit-text-organizer`, or manage it manually.
  1. __Main Script__: Run the script with a file path argument containing the commit messages.
  2. __Commit Message Structure__: Commit messages are organized into groups defined by headers (e.g., "Database Migration 32"). Each group contains commit lines starting with a star (*) and details changes to subjects (files or groups of files).
  3. __Subject Matching and Content Details__: Commit lines within the same header group can be merged if their subjects match. The tool sorts and joins content details alphabetically, separated by a comma-space.
  4. __Line Prefix Shortcuts__: To simplify repetitive prefixes like "Update" or "Create", CTO includes a feature to recognize and replace line prefix shortcuts with their full forms (e.g., "c" for "Create").
  5. __Sorting and Output__: The tool sorts groups and lines within groups alphabetically.
  6. __Output__: The output is printed to the standard output. Pipe it to a file, or it will be printed on screen.


  Python 3.10 or higher is required to run __Commit-Text-Organizer__.
  This is because the Union Type Operator is used (not available in 3.9 or earlier).


  All python modules are contained in the `commit_text_organizer` package. In the following diagram, modules are grouped into symbolic packages for better understanding.

  ![cto](https://github.com/DK96-OS/cto/assets/69859316/67e1735b-6529-4f4e-9360-a7dfe0264431)


  Enhancements should aim to make CTO more versatile, user-friendly, and integrated with workflows. Examples:
  - Run git subprocess and read commit messages from a branch instead of a file
  - Allow users to add their own prefix shortcuts in a config file


pkgId: cb55996ec716d15ffbd895260a871d48ff147d3b94fc660a5eb589a33a747a86
name: python-commit0
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: A development and evaluation framework for using language models to generate libraries.
url: https://commit-0.github.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commit0-0.1.7-1.src.rpm
checksum_type: sha256
description:
  <a href="https://commit-0.github.io/">Commit0</a> is a from scratch AI coding challenge. Can you create a library from commit 0?
  <p align="center">
  <img src="docs/arch.png" width="500px">
  </p>
  <p align="center">
    <a href="https://commit-0.github.io/">
      <img src="https://img.shields.io/badge/Read-Docs-green.svg"/>
    </a>
  </p>
  The benchmark consists of 57 core Python libraries. The challenge is to rebuild these libraries and pass their unit tests. All libraries have:
  * Significant test coverage
  * Detailed specification and documentation
  * Lint and type checking
  Commit0 is an interactive environment that makes it easy to design and test new agents. You can:
  * Efficiently run tests in isolated environments
  * Distribute testing and development across cloud systems
  * Track and log all changes made throughout.
  To install Commit0, run:
  ```
  pip install commit0
  ```
  Commit0 provides several commands to facilitate the process of cloning, building, testing, and evaluating repositories. Here's an overview of the available commands:

  <p align=center>
  <img src="docs/commit0.gif" width="500px">
  </p>
  Use `commit0 setup [OPTIONS] REPO_SPLIT` to clone a repository split.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `repo_split` | str | Split of repositories to clone | |
  | `--dataset-name` | str | Name of the Huggingface dataset | `wentingzhao/commit0_combined` |
  | `--dataset-split` | str | Split of the Huggingface dataset | `test` |
  | `--base-dir` | str | Base directory to clone repos to | `repos/` |
  | `--commit0-config-file` | str | Storing path for stateful commit0 configs | `.commit0.yaml` |

  Use `commit0 build [OPTIONS]` to build the Commit0 split chosen in the Setup stage.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `--num-workers` | int | Number of workers | `8` |
  | `--commit0-config-file` | str | Path to the commit0 dot file | `.commit0.yaml` |
  | `--verbose` | int | Verbosity level (1 or 2) | `1` |

  Use `commit0 get-tests REPO_NAME` to get tests for a Commit0 repository.
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `repo_name` | str | Name of the repository to get tests for | |

  Use `commit0 test [OPTIONS] REPO_OR_REPO_PATH [TEST_IDS]` to run tests on a Commit0 repository.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `repo_or_repo_path` | str | Directory of the repository to test | |
  | `test_ids` | str | Test IDs to run | |
  | `--branch` | str | Branch to test | |
  | `--backend` | str | Backend to use for testing | `modal` |
  | `--timeout` | int | Timeout for tests in seconds | `1800` |
  | `--num-cpus` | int | Number of CPUs to use | `1` |
  | `--reference` | bool | Test the reference commit | `False` |
  | `--coverage` | bool | Get coverage information | `False` |
  | `--rebuild` | bool | Rebuild an image | `False` |
  | `--commit0-config-file` | str | Path to the commit0 dot file | `.commit0.yaml` |
  | `--verbose` | int | Verbosity level (1 or 2) | `1` |
  | `--stdin` | bool | Read test names from stdin | `False` |

  Use `commit0 evaluate [OPTIONS]` to evaluate the Commit0 split chosen in the Setup stage.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `--branch` | str | Branch to evaluate | |
  | `--backend` | str | Backend to use for evaluation | `modal` |
  | `--timeout` | int | Timeout for evaluation in seconds | `1800` |
  | `--num-cpus` | int | Number of CPUs to use | `1` |
  | `--num-workers` | int | Number of workers to use | `8` |
  | `--reference` | bool | Evaluate the reference commit | `False` |
  | `--coverage` | bool | Get coverage information | `False` |
  | `--commit0-config-file` | str | Path to the commit0 dot file | `.commit0.yaml` |
  | `--rebuild` | bool | Rebuild images | `False` |

  Use `commit0 lint [OPTIONS] REPO_OR_REPO_DIR` to lint files in a repository.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `repo_or_repo_dir` | str | Directory of the repository to test | |
  | `--files` | List[Path] | Files to lint (optional) | |
  | `--commit0-config-file` | str | Path to the commit0 dot file | `.commit0.yaml` |
  | `--verbose` | int | Verbosity level (1 or 2) | `1` |

  Use `commit0 save [OPTIONS] OWNER BRANCH` to save the Commit0 split to GitHub.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `owner` | str | Owner of the repository | |
  | `branch` | str | Branch to save | |
  | `--github-token` | str | GitHub token for authentication | |
  | `--commit0-config-file` | str | Path to the commit0 dot file | `.commit0.yaml` |


  Use `agent config [OPTIONS] AGENT_NAME` to set up the configuration for an agent.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `agent_name` | str | Agent to use, we only support [aider](https://aider.chat/) for now. | `aider` |
  | `--model-name` | str | LLM model to use, check [here](https://aider.chat/docs/llms.html) for all supported models. | `claude-3-5-sonnet-20240620` |
  | `--use-user-prompt` | bool | Use a custom prompt instead of the default prompt. | `False` |
  | `--user-prompt` | str | The prompt sent to agent. | See code for details. |
  | `--run-tests` | bool | Run tests after code modifications for feedback. You need to set up `docker` or `modal` before running tests, refer to commit0 docs. | `False` |
  | `--max-iteration` | int | Maximum number of agent iterations. | `3` |
  | `--use-repo-info` | bool | Include the repository information. | `False` |
  | `--max-repo-info-length` | int | Maximum length of the repository information to use. | `10000` |
  | `--use-unit-tests-info` | bool | Include the unit tests information. | `False` |
  | `--max-unit-tests-info-length` | int | Maximum length of the unit tests information to use. | `10000` |
  | `--use-spec-info` | bool | Include the spec information. | `False` |
  | `--max-spec-info-length` | int | Maximum length of the spec information to use. | `10000` |
  | `--use-lint-info` | bool | Include the lint information. | `False` |
  | `--max-lint-info-length` | int | Maximum length of the lint information to use. | `10000` |
  | `--pre-commit-config-path` | str | Path to the pre-commit config file. This is needed for running `lint`. | `.pre-commit-config.yaml` |
  | `--agent-config-file` | str | Path to write the agent config. | `.agent.yaml` |

  Use `agent run [OPTIONS] BRANCH` to execute an agent on a specific branch.
  Available options include:
  | Argument | Type | Description | Default |
  |----------|------|-------------|---------|
  | `branch` | str | Branch to run the agent on, you can specific the name of the branch | |
  | `--backend` | str | Test backend to run the agent on, ignore this option if you are not adding `run_tests` option to agent. | `modal` |
  | `--log-dir` | str | Log directory to store the logs. | `logs/aider` |
  | `--max-parallel-repos` | int | Maximum number of repositories for agent to run in parallel. Running in sequential if set to 1. | `1` |
  | `--display-repo-progress-num` | int | Number of repo progress displayed when running. | `5` |


pkgId: 3d7d1315c061e57be218dfd9b5c3e130308501f39f64b3002a37e74946525522
name: python-commitlint
arch: src
version: 1.3.0
epoch: 0
release: 1
url: https://github.com/opensource-nepal/commitlint
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commitlint-1.3.0-1.src.rpm
checksum_type: sha256
summary:
  commitlint is is a pre-commit hook designed to lint your commit messages according to the Conventional Commits standard.

description:
  [![PyPI version](https://badge.fury.io/py/commitlint.svg)](https://badge.fury.io/py/commitlint)
  [![CI status](https://github.com/opensource-nepal/commitlint/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/opensource-nepal/commitlint/actions)
  [![Downloads](https://img.shields.io/pypi/dm/commitlint.svg?maxAge=180)](https://pypi.org/project/commitlint/)
  [![codecov](https://codecov.io/github/opensource-nepal/commitlint/graph/badge.svg?token=lRmPZsIHb6)](https://codecov.io/github/opensource-nepal/commitlint)
  [![License](https://img.shields.io/pypi/l/commitlint?label=License)](https://github.com/opensource-nepal/commitlint/blob/main/LICENSE)

  commitlint is a tool designed to lint your commit messages according to the [Conventional Commits](https://www.conventionalcommits.org/) standard for your pre-commit hook and GitHub Actions.



  A conventional commit message follows a specific format that includes a prefix indicating the type of change, an optional scope for context, and a concise description of the modification.
  This structure improves readability, facilitates automated changelog generation, and ensures a consistent commit history.

  The commit message should follow this structure:

  ```
  <type>(<optional scope>): <description>

  [Optional body]
  ```

  **Type:** Indicates the type of change, such as build, ci, docs, feat, fix, perf, refactor, style, test, chore, revert, or bump.
  E.g., `feat: add JSON parser`.

  **Scope:** Additional contextual information.
  E.g., `feat(parser): add JSON parser`.

  **Description:** Brief description of the commit.

  **Body:** A detailed description of the commit.

  For more details, please refer to the Conventional Commits specification at https://www.conventionalcommits.org/en/v1.0.0/

  > NOTE: commitlint also checks the length of the commit header (**max 72 characters**). The commit header refers to the first line of the commit message (excluding the body).





  1. Add the following configuration on `.pre-commit-config.yaml`.

     ```yaml
     repos:
        ...
        - repo: https://github.com/opensource-nepal/commitlint
          rev: v1.2.0
          hooks:
            - id: commitlint
        ...
     ```

  2. Install the `commit-msg` hook in your project repo:

     ```bash
     pre-commit install --hook-type commit-msg
     ```

     Installing using only `pre-commit install` will not work.

  > **_NOTE:_** Avoid using commit messages that start with '#'.
  > This might result in unexpected behavior with commitlint.



  If you have any existing workflows, add the following steps:

  ```yaml
  ...
  steps:
      ...
      - name: Run commitlint
        uses: opensource-nepal/commitlint@v1
      ...
  ```

  If you don't have any workflows, create a new GitHub workflow, e.g. `.github/workflows/commitlint.yaml`.

  ```yaml
  name: Commitlint

  on:
    push:
      branches: ['main']
    pull_request:

  jobs:
    commitlint:
      runs-on: ubuntu-latest
      name: Commitlint
      steps:
        - name: Run commitlint
          uses: opensource-nepal/commitlint@v1
  ```

  > **_NOTE:_** commitlint GitHub Actions will only be triggered by "push", "pull_request", or "pull_request_target" events. The difference between "pull_request" and "pull_request_target" is that "pull_request" is more secure for public repos while "pull_request_target" is necessary for private repos.



  | #   | Name              | Type    | Default                | Description                                                           |
  | --- | ----------------- | ------- | ---------------------- | --------------------------------------------------------------------- |
  | 1   | **fail_on_error** | Boolean | `true`                 | Determines whether the GitHub Action should fail if commitlint fails. |
  | 2   | **verbose**       | Boolean | `false`                | Verbose output.                                                       |
  | 3   | **token**         | String  | `secrets.GITHUB_TOKEN` | Github Token for fetching commits using Github API.                   |



  | #   | Name          | Type    | Description                                                                  |
  | --- | ------------- | ------- | ---------------------------------------------------------------------------- |
  | 1   | **exit_code** | Integer | The exit code of the commitlint step.                                        |
  | 2   | **status**    | String  | The outcome of the commitlint step. Possible values: 'success' or 'failure'. |





  ```shell
  pip install commitlint
  ```



  ```
  commitlint [-h] [-V] [--file FILE] [--hash HASH] [--from-hash FROM_HASH] [--to-hash TO_HASH] [--skip-detail] [-q | -v]
             [commit_message]

  positional arguments:
    commit_message        The commit message to be checked

  optional arguments:
    -h, --help            show this help message and exit
    -V, --version         show program's version number and exit
    --file FILE           Path to a file containing the commit message
    --hash HASH           Commit hash
    --from-hash FROM_HASH
                          From commit hash
    --to-hash TO_HASH     To commit hash
    --skip-detail         Skip the detailed error message check
    -q, --quiet           Ignore stdout and stderr
    -v, --verbose         Verbose output
  ```



  Check commit message directly:

  ```shell
  $ commitlint "chore: my commit message"
  ```

  Check commit message from file:

  ```shell
  $ commitlint --file /foo/bar/commit-message.txt
  ```

  > **_NOTE:_** For `--file` option, avoid using commit messages that start with '#'.
  > This might result in unexpected behavior with commitlint.

  Check commit message of a hash:

  ```shell
  $ commitlint --hash 9a8c08173
  ```

  Check commit message of a hash range:

  ```shell
  $ commitlint --from-hash 00bf73fef7 --to-hash d6301f1eb0
  ```

  Check commit message skipping the detail check:

  ```shell
  $ commitlint --skip-detail "chore: my commit message"

  $ commitlint --skip-detail --hash 9a8c08173
  ```

  Run commitlint in quiet mode:

  ```shell
  $ commitlint --quiet "chore: my commit message"
  ```

  Run commitlint in verbose mode:

  ```shell
  $ commitlint --verbose "chore: my commit message"
  ```

  Version check:

  ```shell
  $ commitlint --version

  $ commitlint -V
  ```



  We appreciate feedback and contribution to this package. To get started please see our [contribution guide](./CONTRIBUTING.md).


pkgId: c55ec34e6d4aba3cc7f49e77aac231264a1ab85cd095ad4f8e049f6d73768486
name: python-commitloom
arch: src
version: 0.3.0
epoch: 0
release: 1
description: <p align="center">Crafted with 🧵 by <a href="https://github.com/Arakiss">@Arakiss</a></p>
url: https://github.com/Arakiss/commitloom
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commitloom-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  Weave perfect git commits with AI-powered intelligence. An intelligent CLI tool that uses OpenAI to generate meaningful, structured commit messages.


pkgId: fa1ee2544114e34479faea73248c9542ad5a235904b64a879e024264aa816312
name: python-commitment
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: An incomplete Python 3 wrapper for the GitHub API
url: https://github.com/chris48s/commitment
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commitment-4.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Run tests](https://github.com/chris48s/commitment/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/chris48s/commitment/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/chris48s/commitment/branch/master/graph/badge.svg?token=4BL8HL7913)](https://codecov.io/gh/chris48s/commitment)
  ![PyPI Version](https://img.shields.io/pypi/v/commitment.svg)
  ![License](https://img.shields.io/pypi/l/commitment.svg)
  ![Python Compatibility](https://img.shields.io/badge/dynamic/json?query=info.requires_python&label=python&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fcommitment%2Fjson)
  ![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)

  An incomplete Python 3 wrapper for the [GitHub API](https://developer.github.com/v3/).

  Note this project does not aim to provide a complete abstraction over the GitHub API - just a few high-level convenience methods for pushing data to a GitHub repo.



  `pip install commitment`



  Generate a GitHub API key: https://github.com/settings/tokens

  ```python
  from commitment import GitHubCredentials, GitHubClient

  credentials = GitHubCredentials(
      repo="myuser/somerepo",
      name="myuser",
      email="someone@example.com",
      api_key="f00b42",
  )

  client = GitHubClient(credentials)

  client.create_branch('my_new_branch', base_branch='master')
  client.push_file('Hello World!', 'directory/filename.txt', 'my commit message', branch='my_new_branch')
  client.open_pull_request('my_new_branch', 'title', 'body', base_branch='master')
  ```


pkgId: 3ee1210cac6c3d0e028f40d07f239020dcca6910ea4c80ab40d46cb7962f92e2
name: python-commits2pdf
arch: src
version: 1.1.17
epoch: 0
release: 1
summary: Convert Git commits to a PDF
url: https://github.com/tomasvana10/commits2pdf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commits2pdf-1.1.17-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

    
    ![Licence](https://img.shields.io/badge/licence-MIT-green?style=flat?logo=licence)
    [![PyPI version](https://img.shields.io/pypi/v/commits2pdf?style=flat-square)](https://pypi.org/project/commits2pdf/)
    [![Publish to PyPI.org](https://github.com/tomasvana10/commits2pdf/actions/workflows/publish.yml/badge.svg)](https://github.com/tomasvana10/commits2pdf/actions/workflows/publish.yml)
    [![Release](https://img.shields.io/github/v/release/tomasvana10/commits2pdf?logo=github)](https://github.com/tomasvana10/commits2pdf/releases/latest)
    [![Issues](https://img.shields.io/github/issues-raw/tomasvana10/commits2pdf.svg?maxAge=25000)](https://github.com/tomasvana10/commits2pdf/issues)
    [![CodeQL](https://github.com/tomasvana10/commits2pdf/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/tomasvana10/commits2pdf/actions/workflows/github-code-scanning/codeql)
    [![Tests](https://github.com/tomasvana10/commits2pdf/actions/workflows/tox-tests.yml/badge.svg)](https://github.com/tomasvana10/commits2pdf/actions/workflows/tox-tests.yml)

  </div>

  Visualise a Git repository's commit history in PDF form via the command-line

  ![ezgif-pdf-tutorial](https://github.com/tomasvana10/commits2pdf/assets/124552709/fcc4b5da-2326-4405-80fe-cf984f61129c)


  `GitPython` `fpdf` `progressbar` `pathvalidate`

  `pycairo` (used for deprecated PDF generation method, must be installed manually)


  > [!IMPORTANT]
  > Installing `commits2pdf` requires Python and pip.
  > If you have Python installed without pip, click **[here](https://pip.pypa.io/en/stable/installation/)** to install it.<br><br>
  > If you do not have Python installed, download the installer **[here](https://www.python.org/downloads/)**, then refer to the previous link on how to install pip.<br><br>
  > Additionaly, `commits2pdf` requires Git for `gitpython` functionality. Install it **[here](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)**.

  > [!TIP]
  > If using `python` or `pip` doesn't work, try using `python3` or `pip3`.

  1. Make a virtual environment and activate it (recommended):

      - Before you make a virtual environment, you should change your current directory to the folder of your repository. If you don't know how, read [Changing your terminal's directory](#changing-your-terminals-directory).
      - If you are on Windows and you cannot activate the virtual environment, try running `Set-ExecutionPolicy Unrestricted -Scope Process` and try again.
  ```
  pip install virtualenv
  python -m venv venv
  MacOS/Unix: source venv/bin/activate
  Windows: venv\scripts\activate
  ```
  2. Install the package in your system directory/virtual environment:
  ```
  pip install -U commits2pdf
  ```
  or, install the package in your home directory if you aren't using a virtual environment:
  ```
  pip install --user -U commits2pdf
  ```
  3. You can deactivate your virtual environment when you are done:
  ```
  deactivate
  ```

  > [!TIP]
  > **If you encounter errors with building `pycairo`, click [here](https://stackoverflow.com/a/76175684/23245953)**


  1. Open your terminal
  2. Find your repository's folder
  3. (a) On Windows/Linux: Open the folder, press `CTRL+L`, then press `CTRL+C`. Alternatively, right click on the folder and click `Copy as path`.
  3. (b) On MacOS: Right click on the folder, hold `option` (`⌥`) and click `Copy <folder name> as Pathname`

  Then, in your terminal, run `cd <the path you copied>` (paste in the path with `CTRL+V` or `CMD+V`).


  There are many ways to configure the process of PDF generation through command line flags. For a brief introduction on how to use these flags, read [Usage](#usage)

  <details><summary>Positional Flags</summary>

  `owner` : The owner of the git repository. Required.

  </details>

  <details><summary>Optional Flags</summary>

    `-o`, `--output` : Directory path to your PDF output. Set to `.` (your current directory) by default. Will be created if it does not exist. Example: `./work/my_pdfs`

    `-n`, `--name` : The name of your outputted PDF file. Set to `<repo_name>-commit_report` by default.

    `-b`, `--branch` : The repository branch. Set to `main` by default.

    `-a`, `--authors` : Filter commits from a comma-separated list of authors. Format: `<author@email.com>` OR `<author1@email.com,author2@email.com>` etc. Set to `all authors` by default.

    `-s`, `--start-date` : Filter from start date of commits. Format: `d/m/YYYY`. Example: `5/12/2023`

    `-e`, `--end-date` : Filter to end date of commits. Format: `d/m/YYYY`. Example: `5/12/2023`

    `-r`, `--reverse` : Output the commits from newest to oldest. Set to `oldest to newest` by default

    `-d`, `--dark` : Toggle dark mode for the output PDF. Set to `light` by default.

    `-po`, `--prevent-open` : Prevent commits2pdf from automatically opening the directory the PDF was created in.

    `-sc`, `--scaling` : Set the scaling of the output PDF. Only available with `-gen2a` and `-gen2b`.

    `-in`, `--include` : Include commits with the given string sequences in their title or description. Format: `<string1>` OR `<string1,string2>`. Whitespace sensitive and case insensitive. NOTE: This query is performed BEFORE excluding commits.

    `-ex`, `--exclude` : Exclude commits with the given string sequences in their title or description. Format: `<string1>` OR `<string1,string2>`. Whitespace sensitive and case insensitive.

    `-q`, `--quiet` : Suppress all logger messages except for errors.

    `-gen1`, `--pdf-gen-1 ` : PDF rendering implementation with `pycairo`.

    `-gen2a`, `--pdf-gen-2a` : The first PDF rendering implementation with `fpdf`.

    `-gen2b`, `--pdf-gen-2b` : The second PDF rendering implementation with `fpdf`. The default option.

    `-rp`, `--repo-path` : Path to your repository directory. Set to `.` (your current directory) by default.

    `-fc`, `--repo-from-clone` : Clone a repo into the working directory and generate the commits PDF from it automatically. Format: `<repo name>` (case insensitive).

    `-nc`, `--newest-n-commits` : Select the newest n number amount of commits to include after filtering.

    `-oc`, `--oldest-n-commits` : Select the oldest n number amount of commits to include after filtering.

  </details>



  > [!TIP]
  > If the value you are providing for a given argument/flag includes spaces, wrap in it quotations ("") to ensure it is parsed properly.

  **Usage example #1**
  ```
  c2p tomasvana10
  ```
  > Output a PDF to your current directory (assuming it is a git repository that is owned by `tomasvana10`).

  <br>**Usage example #2**
  ```
  c2p tomasvana10 -o .. -rp ./my_repo -n "new_name.pdf"
  ```
  > Output a PDF (overriding its name to `new_name`) to the parent directory, selecting `./my_repo` as your git repository to access the commits from.

  <br>**Usage example #3**
  ```
  c2p tomasvana10 -nc 10 -in "javascript,build" -ex "testing"
  ```
  > Output a PDF to the current directory, displaying the newest 10 commits after filtering commits that contain "javascript" and/or "build" in their title or description and do not contain "testing".

  <br>**Usage example #4**
  ```
  c2p devguarv -fc Yr-12-HSC-SDD-Task-2 -e 28/4/2024
  ```
  > Clone the repo `Yr-12-HSC-SDD-Task-2` into the current directory and output a PDF into the same place after filtering commits that were made up to `28/4/2024`.



  👍 Fast

  👎 Cannot write multipage commits

  👎 Looks like crap

  👎 No hyperlinks, therefore the entire link to a commit's diff is displayed


  👍 Fast

  👍 Can be scaled with the `-sc <float>` argument<

  👍 Sleek design

  👍 Information title page

  👍 Contains hyperlinks

  👍 Stores PDF metadata

  👎 Inconsistent page breaks, a general limitation with FPDF when trying to fit as many whole commits on a single page


  👍 Same as `gen2a` but with accurate page breaking

  👎 Slow when generating large amounts of commits (generally, it is a good idea to enable `-gen2a` when drawing over 5000 commits)


pkgId: 8f9f9dda3b287eb6263b4801c5acc6f47e42ffa9f91e4f65cd0d84ed210491dd
name: python-commitzilla
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Make your commit messages helpful, for once
url: https://pypi.org/project/commitzilla/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commitzilla-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="./icon.png" alt="Icon" />
  </p>

  Welcome to **commitzilla**! This is a simple git hook that will hijack your commit messages, and translate them into detailed, comprehensive messages, fit for anyone and everyone!

  <p align="center">
    <img src="./example.gif" alt="Example GIF" />
  </p>



  Installation is soooooo easy, just pip install the package:

  ```
  pip install commitzilla
  ```

  then navigate to the directory of your local git repo where you want to install the hook, and run:

  ```
  commitzilla install
  ```

  and bob's your uncle.



  You can change the character style of the commit message (or add your own custom one) by running:

  ```
  commitzilla character
  ```

  You can edit the OpenAI model (other providers coming soon) and the OpenAPI key with the configure command, for more info, run:

  ```
  commitzilla configure
  ```

  You can also enable a prefix, so your messages will look like this: `[Character] Commit message` so you can keep track of which commits are good and which are bad:

  ```
  commitzilla prefix
  ```



  Not sure why you're reading this... but anyways, removing commitzilla is even easier than installing it,
  just navigate to the directory you want to remove the hook, and run:

  ```
  commitzilla uninstall
  ```


pkgId: e56d9376221703dd45a3255385ba6ee13795dee885fce76bd4031a76a6df7569
name: python-commlib-py
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: Internal DSL for communication and messaging in CyberPhysical Systems
url: https://pypi.org/project/commlib-py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commlib-py-0.11.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/commlib-py.svg)](https://badge.fury.io/py/commlib-py) [![Downloads](https://static.pepy.tech/badge/commlib-py)](https://pepy.tech/project/commlib-py) [![Downloads](https://static.pepy.tech/badge/commlib-py/month)](https://pepy.tech/project/commlib-py) [![Downloads](https://static.pepy.tech/badge/commlib-py/week)](https://pepy.tech/project/commlib-py)

  ![image](https://github.com/robotics-4-all/commlib-py/assets/4770702/0dc3db01-eb5e-40a2-9d3a-07d25613fc86)




  Commlib is an **internal DSL** for communication and messaging in **Cyber-Physical Systems**. Can be used for
  rapid development of the communication layer on-device, at the Edge and on the Cloud.

  The goal of this project is to implement a simple Protocol-agnostic API (AMQP, Kafka, Redis, MQTT, etc)
  for common communication patterns in the context of Cyber-Physical Systems, using message broker
  technologies. Such patterns include PubSub, RPC and Preemptive Services (aka Actions), among others.

  ![Broker_A](https://github.com/robotics-4-all/commlib-py/assets/4770702/ab009804-75aa-4272-a471-b3f966e4011c)





  Install from PyPi:

  ```bash
  pip install commlib-py
  ```

  Alternatively, download this repo and install using setuptools:

  ```
  git clone git@github.com:robotics-4-all/commlib-py.git
  cd commlib-py && python setup.py install
  ```

  Commlib can also be used in a virtual envirtonment

  ```
  python -m venv myvenv
  pip install commlib-py
  ```



  It is recommended to use a fast json library, such as [orjson](https://github.com/ijl/orjson)
  or [ujson](https://github.com/ultrajson/ultrajson).

  The framework will load and use the most performance optimal library based
  on installations. The default is `ujson`.





  A **Node** is a software component that follows the Component-Port-Connector model.
  It has input and output ports for communicating with the world. Each
  port defines an endpoint and can be of the following types.

  **Input Port**:
    - Subscriber
    - RPC Service
    - Action Service

  **Output Port**:
    - Publisher
    - RPC Client
    - Action Client

  **InOut Port**:
    - RPCBridge: Bridge RPC Communication between two brokers. Directional.
    - TopicBridge: Bridge PubSub Communication between two brokers. Directional.
    - PTopicBridge: Bridge PubSub Communication between two brokers, based on a topic pattern. Directional.


  Furthermore, it implements several features:
  - Publish Heartbeat messages in the background for as long as the node is active
  - Provide control interfaces, to `start` and `stop` the execution of the Node
  - Provides methods to create endpoints and bind to Node ports.

  ```python
  from commlib.node import Node, TransportType
  from commlib.msg import RPCMessage


  from commlib.transports.redis import ConnectionParameters


  class AddTwoIntMessage(RPCMessage):
      class Request(RPCMessage.Request):
          a: int = 0
          b: int = 0

      class Response(RPCMessage.Response):
          c: int = 0


  def on_request(msg):
      print(f'On-Request: {msg}')
      resp = AddTwoIntMessage.Response(c = msg.a + msg.b)
      return resp


  if __name__ == '__main__':
      conn_params = ConnectionParameters()
      node = Node(node_name='add_two_ints_node',
                  connection_params=conn_params,
                  
                  debug=True)
      rpc = node.create_rpc(msg_type=AddTwoIntMessage,
                            
                            on_request=add_two_int_handler)
      node.run_forever(sleep_rate=1)
  ```

  A Node always binds to a specific broker for implementing the input and
  output ports. Of course you can instantiate and run several Nodes in a single-process
  application.

  **Node class:**

  ```py
  class Node:

      def __init__(self,
                   node_name: Optional[str] = '',
                   connection_params: Optional[Any] = None,
                   transport_connection_params: Optional[Any] = None,
                   debug: Optional[bool] = False,
                   heartbeats: Optional[bool] = True,
                   heartbeat_uri: Optional[str] = None,
                   compression: CompressionType = CompressionType.NO_COMPRESSION,
                   ctrl_services: Optional[bool] = False):
  ```

  Node methods to create and run Endpoints::

  ```py
  Node:
     create_action(self, *args, **kwargs)
     create_action_client(self, *args, **kwargs)
     create_event_emitter(self, *args, **kwargs)
     create_heartbeat_thread(self)
     create_mpublisher(self, *args, **kwargs)
     create_psubscriber(self, *args, **kwargs)
     create_publisher(self, *args, **kwargs)
     create_rpc(self, *args, **kwargs)
     create_rpc_client(self, *args, **kwargs)
     create_start_service(self, uri: str = None)
     create_stop_service(self, uri: str = None)
     create_subscriber(self, *args, **kwargs)
     run_forever(self, sleep_rate: float = 0.001)
     run(self)
     stop(self)
  ```



  It is possible to construct endpoints without binding them to a specific
  Node. This is a feature to support a wider range of applications, where the
  concept Node might not be usable.

  One can create endpoint instances by using the following classes of each
  supported transport

  - RPCClient
  - RPCServer
  - Publisher
  - Subscriber
  - MPublisher (Multi-topic Publisher)
  - PSubscriber (Pattern-based Subscriber)
  - ActionService (Preemptable Services with feedback)
  - ActionClient


  ```python
  from commlib.transports.redis import RPCService
  from commlib.transports.amqp import Subscriber
  from commlib.transports.mqtt import Publisher, RPCClient
  ...
  ```

  Or use the `endpoint_factory` to construct endpoints.

  ```python
  import time
  from commlib.endpoints import endpoint_factory, EndpointType, TransportType


  def callback(data):
      print(data)


  if __name__ == '__main__':
      topic = 'factory_test_topic'
      mqtt_sub = endpoint_factory(
          EndpointType.Subscriber,
          TransportType.MQTT
      )(topic=topic, on_message=callback)
      mqtt_sub.run()
      mqtt_pub = endpoint_factory(
          EndpointType.Publisher,
          TransportType.MQTT
      )(topic=topic, debug=True)

      data = {'a': 1, 'b': 2}
      while True:
          mqtt_pub.publish(data)
          time.sleep(1)
  ```



  ![image](https://github.com/robotics-4-all/commlib-py/assets/4770702/b1a27e08-0ddd-4498-a882-1c255e36a1c4)






  ```python
  from commlib.msg import RPCMessage
  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters


  class AddTwoIntMessage(RPCMessage):
      class Request(RPCMessage.Request):
          a: int = 0
          b: int = 0

      class Response(RPCMessage.Response):
          c: int = 0


  def add_two_int_handler(msg):
      print(f'Request Message: {msg.__dict__}')
      resp = AddTwoIntMessage.Response(c = msg.a + msg.b)
      return resp


  if __name__ == '__main__':
      conn_params = ConnectionParameters()
      node = Node(
          node_name='add_two_ints_node',
          connection_params=conn_params,
          
          debug=True
      )
      rpc = node.create_rpc(
          msg_type=AddTwoIntMessage,
          rpc_name='add_two_ints_node.add_two_ints',
          on_request=add_two_int_handler
      )
      node.run_forever(sleep_rate=1)
  ```



  ```python
  import time

  from commlib.msg import RPCMessage
  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters


  class AddTwoIntMessage(RPCMessage):
      class Request(RPCMessage.Request):
          a: int = 0
          b: int = 0

      class Response(RPCMessage.Response):
          c: int = 0


  if __name__ == '__main__':
      conn_params = ConnectionParameters()
      node = Node(node_name='myclient',
                  connection_params=conn_params,
                  
                  debug=True)
      rpc = node.create_rpc_client(
          msg_type=AddTwoIntMessage,
          rpc_name='add_two_ints_node.add_two_ints'
      )
      node.run()

      
      msg = AddTwoIntMessage.Request()
      while True:
          
          resp = rpc.call(msg)
          print(resp)
          msg.a += 1
          msg.b += 1
          time.sleep(1)
  ```




  Traditional Topic-based Publish-Subscribe pattern for asynchronous communication as depicted below.


  An example of using PubSub communication is located at [examples/simple_pubsub](https://github.com/robotics-4-all/commlib-py/tree/docs/examples/simple_pubsub).




  ```python
  from commlib.msg import MessageHeader, PubSubMessage
  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters

  class SonarMessage(PubSubMessage):
      header: MessageHeader = MessageHeader()
      range: float = -1
      hfov: float = 30.6
      vfov: float = 14.2


  class SonarMessage(PubSubMessage):
      distance: float = 0.001
      horizontal_fov: float = 30.0
      vertical_fov: float = 14.0


  if __name__ == "__main__":
      conn_params = ConnectionParameters(host='localhost', port=1883)
      node = Node(node_name='sensors.sonar.front',
                  connection_params=conn_params,
                  
                  debug=True)

      pub = node.create_publisher(msg_type=SonarMessage,
                                  topic='sensors.sonar.front')
      node.run()

      msg = SonarMessage()
      while True:
          pub.publish(msg)
          msg.range += 1
          time.sleep(1)
  ```



  ```python


  import time

  from commlib.msg import MessageHeader, PubSubMessage
  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters


  class SonarMessage(PubSubMessage):
      header: MessageHeader = MessageHeader()
      range: float = -1
      hfov: float = 30.6
      vfov: float = 14.2


  def on_message(msg):
      print(f'Received front sonar data: {msg}')


  if __name__ == '__main__':
      conn_params = ConnectionParameters()

      node = Node(node_name='obstacle_avoidance_node',
                  connection_params=conn_params,
                  
                  debug=True)

      node.create_subscriber(msg_type=SonarMessage,
                             topic='sensors.sonar.front',
                             on_message=on_message)

      node.run_forever(sleep_rate=1)
  ```



  For pattern-based topic subscription one can also use the `PSubscriber` class directly.

  For multi-topic publisher one can also use the `MPublisher` class directly.


  ```python






  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters

  def on_message(msg, topic):
      print(f'Message at topic <{topic}>: {msg}')


  if __name__ == '__main__':
      conn_params = ConnectionParameters()
      node = Node(node_name='example5_listener',
                  connection_params=conn_params,
                  debug=True)

      node.create_psubscriber(topic='topic.*', on_message=on_message)
      node.run_forever()
  ```

  ```python






  from commlib.node import Node
  from commlib.transports.mqtt import ConnectionParameters

  def on_message(msg, topic):
      print(f'Message at topic <{topic}>: {msg}')


  if __name__ == '__main__':
      conn_params = ConnectionParameters()
      node = Node(node_name='example5_publisher',
                  connection_params=conn_params,
                  debug=True)

      pub = node.create_mpublisher()
      node.run()

      topicA = 'topic.a'
      topicB = 'topic.b'

      while True:
          pub.publish({'a': 1}, topicA)
          pub.publish({'b': 1}, topicB)
          time.sleep(1)
  ```



  ```python
  from commlib.msg import MessageHeader, PubSubMessage, RPCMessage
  from commlib.node import Node, TransportType
  from commlib.transports.redis import ConnectionParameters


  class SonarMessage(PubSubMessage):
      header: MessageHeader = MessageHeader()
      range: float = -1
      hfov: float = 30.6
      vfov: float = 14.2


  class AddTwoIntMessage(RPCMessage):
      class Request(RPCMessage.Request):
          a: int = 0
          b: int = 0

      class Response(RPCMessage.Response):
          c: int = 0


  conn_params = ConnectionParameters()

  node = Node(node_name='obstacle_avoidance_node',
              connection_params=conn_params,
              debug=True)


  @node.subscribe('sensors.sonar.front', SonarMessage)
  def on_message(msg):
      print(f'Received front sonar data: {msg}')


  @node.rpc('add_two_ints_node.add_two_ints', AddTwoIntMessage)
  def add_two_int_handler(msg):
      print(f'Request Message: {msg.__dict__}')
      resp = AddTwoIntMessage.Response(c = msg.a + msg.b)
      return resp


  node.run_forever(sleep_rate=0.01)
  ```



  Actions are [pre-emptable services](https://en.wikipedia.org/wiki/Preemption_(computing))
  with support for asynchronous feedback publishing. This communication pattern
  is used to implement services which can be stopped and can provide feedback data, such
  as the move command service of a robot.




  ```python
  import time

  from commlib.action import GoalStatus
  from commlib.msg import ActionMessage
  from commlib.transports.redis import ConnectionParameters
  )


  class ExampleAction(ActionMessage):
      class Goal(ActionMessage.Goal):
          target_cm: int = 0

      class Result(ActionMessage.Result):
          dest_cm: int = 0

      class Feedback(ActionMessage.Feedback):
          current_cm: int = 0


  def on_goal(goal_h):
      c = 0
      res = ExampleAction.Result()
      while c < goal_h.data.target_cm:
          if goal_h.cancel_event.is_set():
              break
          goal_h.send_feedback(ExampleAction.Feedback(current_cm=c))
          c += 1
          time.sleep(1)
      res.dest_cm = c
      return res


  if __name__ == '__main__':
      action_name = 'testaction'
      conn_params = ConnectionParameters()
      node = Node(node_name='action_service_example_node',
                  connection_params=conn_params,
                  
                  debug=True)
      node.create_action(msg_type=ExampleAction,
                         action_name=action_name,
                         on_goal=on_goal)
      node.run_forever()
  ```



  ```python
  import time

  from commlib.action import GoalStatus
  from commlib.msg import ActionMessage
  from commlib.transports.redis import ActionClient, ConnectionParameters


  class ExampleAction(ActionMessage):
      class Goal(ActionMessage.Goal):
          target_cm: int = 0

      class Result(ActionMessage.Result):
          dest_cm: int = 0

      class Feedback(ActionMessage.Feedback):
          current_cm: int = 0


  def on_feedback(feedback):
      print(f'ActionClient <on-feedback> callback: {feedback}')


  def on_result(result):
      print(f'ActionClient <on-result> callback: {result}')


  def on_goal_reached(result):
      print(f'ActionClient <on-goal-reached> callback: {result}')


  if __name__ == '__main__':
      action_name = 'testaction'
      conn_params = ConnectionParameters()
      node = Node(node_name='action_client_example_node',
                  connection_params=conn_params,
                  
                  debug=True)
      action_client = node.create_action_client(
          msg_type=ExampleAction,
          action_name=action_name,
          on_goal_reached=on_goal_reached,
          on_feedback=on_feedback,
          on_result=on_result
      )
      node.run()
      goal_msg = ExampleAction.Goal(target_cm=5)
      action_client.send_goal(goal_msg)
      resp = action_client.get_result(wait=True)
      print(f'Action Result: {resp}')
      node.stop()
  ```



  In the context of IoT and CPS, it is a common requirement to bridge messages
  between message brokers, based on application-specific rules. An example is to
  bridge analytics (preprocessed) data from the Edge to the Cloud. And what happens
  if the brokers use different communication protocols?

  ![image](https://github.com/robotics-4-all/commlib-py/assets/4770702/98993090-abfd-4e9f-b16e-ad9b7f436987)


  Below are examples of an MQTT Redis-to-MQTT Bridge and a Redis-to-MQTT
  Topic Bridge.

  ```python


  import time

  import commlib.transports.amqp as acomm
  import commlib.transports.redis as rcomm
  import commlib.transports.mqtt as mcomm

  from commlib.bridges import (
      RPCBridge, RPCBridgeType, TopicBridge, TopicBridgeType
  )


  def redis_to_mqtt_rpc_bridge():
      """
      [RPC Client] ----> [Broker A] ------> [Broker B] ---> [RPC Service]
      """
      bA_params = rcomm.ConnectionParameters()
      bB_params = mcomm.ConnectionParameters()
      bA_uri = 'ops.start_navigation'
      bB_uri = 'thing.robotA.ops.start_navigation'
      br = RPCBridge(RPCBridgeType.REDIS_TO_MQTT,
                     from_uri=bA_uri, to_uri=bB_uri,
                     from_broker_params=bA_params,
                     to_broker_params=bB_params,
                     debug=False)
      br.run()


  def redis_to_mqtt_topic_bridge():
      """
      [Producer Endpoint] ---> [Broker A] ---> [Broker B] ---> [Consumer Endpoint]
      """
      bA_params = rcomm.ConnectionParameters()
      bB_params = mcomm.ConnectionParameters()
      bA_uri = 'sonar.front'
      bB_uri = 'thing.robotA.sensors.sonar.font'
      br = TopicBridge(TopicBridgeType.REDIS_TO_MQTT,
                       from_uri=bA_uri, to_uri=bB_uri,
                       from_broker_params=bA_params,
                       to_broker_params=bB_params,
                       debug=False)
      br.run()


  if __name__ == '__main__':
      redis_to_mqtt_rpc_bridge()
      redis_to_mqtt_topic_bridge()
  ```

  A Pattern-based Topic Bridge (PTopicBridge) example is also shown below.
  In this example, we use static definition of messages (`SonarMessage`), also
  referred as `typed communication`.


  ```python


  import time

  from commlib.msg import PubSubMessage
  from commlib.bridges import PTopicBridge
  import commlib.transports.amqp as acomm
  import commlib.transports.redis as rcomm


  class SonarMessage(PubSubMessage):
      distance: float = 0.001
      horizontal_fov: float = 30.0
      vertical_fov: float = 14.0


  if __name__ == '__main__':
      """
      [Broker A] ------------> [Broker B] ---> [Consumer Endpoint]
      """
      bA_uri = 'sensors.*'
      bB_namespace = 'myrobot'

      bA_params = rcomm.ConnectionParameters()
      bB_params = mcomm.ConnectionParameters()

      br = PTopicBridge(TopicBridgeType.REDIS_TO_MQTT,
                        bA_uri,
                        bB_namespace,
                        bA_params,
                        bB_params,
                        msg_type=SonarMessage,
                        debug=False)
      br.run()
  ```





  TCP bridge forwards tcp packages between two endpoints:

  ```

  [Client] -------> [TCPBridge, port=xxxx] ---------> [TCP endpoint, port=xxxx]

  ```

  A one-to-one connection is performed between the bridge and the endpoint.




  Implements a REST proxy, that enables invocation of REST services via
  broker communication. The proxy uses an RPCService to run the broker endpoint and
  an http client for calling REST services. An RPC call is transformed into proper,
  REST-compliant, http request, based on the input parameters.

  ![image](https://github.com/robotics-4-all/commlib-py/assets/4770702/1507cb10-00ec-49ce-8159-967c23d1ba72)



  ```python
  class RESTProxyMessage(RPCMessage):
      class Request(RPCMessage.Request):
          base_url: str
          path: str = '/'
          verb: str = 'GET'
          query_params: Dict = {}
          path_params: Dict = {}
          body_params: Dict = {}
          headers: Dict = {}

      class Response(RPCMessage.Response):
          data: Union[str, Dict, int]
          headers: Dict[str, Any]
          status_code: int = 200
  ```

  Responses from the REST services are returned to clients in the form of a
  `RPCMessage.Response` message.






  RPC (request/reply) and PubSub Endpoints are supported by the protocol itself (AMQP), using dedicated exchanges.

  For RPC enpoints a `Direct Exchange` is used to route requests and responses,
  optionally using the [Direct Reply-to](https://www.rabbitmq.com/direct-reply-to.html).
  If the `Direct Reply-to` feature is used, then RPC endpoints must publish
  to the default exchange `""`.

  To use `Direct Reply-to`, an RPC client should:
  - Consume from the pseudo-queue `amq.rabbitmq.reply-to` in no-ack mode.
  - Set the `reply-to` property in their request message to `amq.rabbitmq.reply-to`.

  Meta-information such as the serialization method used, is passed through the
  [message properties](https://www.rabbitmq.com/consumers.html#message-properties)
  metadata, as specified my AMQP.




  Req/Resp communication (RPC) is not supported out-of-the-box. To support
  RPC communication over Redis, a custom layer implements the pattern for both endpoints
  using Redis Lists to represent queues. RPC server listens for requests from
  a list (LPOP / BLPOP), while an RPC client sends request messages to that list (RPUSH).
  In order for the client to be able to receive responses, he must listen to a temporary queue.
  To achieve this, the request message must include a `reply_to` property that is
  used by the RPCServer implementation to send the response message. Furthermore,
  `serialization` and `encoding` properties are defined. Finally, the header
  includes a `timestamp`, that indicates the time that the message was sent to to wire.


  Below is the  data model of the request message.

  ```
  {
    'data': {},
    'header': {
      'timestamp': <int>,
      'reply_to': <str>,
      'content_type': 'application/json',
      'content_encoding': 'utf8',
      'agent': 'commlib'
    }
  }
  ```

  **Note**: The **RPC Client** implementation is responsible to remove any created
  temporary queues!




  Req/Resp communication (RPC) is not supported out-of-the-box. To support
  RPC communication over MQTT, a custom layer implements the pattern for both endpoints
  using MQTT topics. RPC server listens for requests at a specific topic,
  while an RPC client listens to a temporary topic for response messages.
  For the server to know where to send the response, the request message must include a `reply_to` property that is
  used by the RPCServer implementation to send the response message. Furthermore,
  `serialization` and `encoding` properties are defined. Finally, the header
  includes a `timestamp`, that indicates the time that the message was sent to to wire.

  Below is the data model of the Request message.

  ```
  {
    'data': {},
    'header': {
      'timestamp': -1,
      'reply_to': "UNIQUE_NAME",
      'content_type': 'application/json',
      'content_encoding': 'utf8',
      'agent': 'commlib',
    }
  }
  ```



  Examples can be found at the [examples/](./examples) directory of this repository.




  Run tests by executing `tox` command under this repo directory:

  ```bash
  make tests
  ```



  Starting from 2024 (>0.11.3) only PRs from the `devel` branch are merged into the `master` branch.

  Other branches are merged into `devel` first.

  Types of branches:

  - Bug fix: `fix/<bug_short_name>`
  - New feature: `feat/<feature_short_name>`
  - Documentation: `doc/<doc_short_name>`

  New versions will be released from the `master` branch after a PR request from `devel`.


pkgId: 204608872686cd4b5a0231d4a73442b5cb3ed3dbbe385ee521499e0a5f76247e
name: python-common
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Common tools and data structures implemented in pure python.
url: https://pypi.python.org/pypi/common
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Copyright (c) 2016 Marcel Hellkamp
  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: e1bc302d157170a784f7bfb382ace388bf8453904420ef25b40c085ffc0b9d36
name: python-common-harness-lib
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: Helper package for H2H Task images.
url: https://github.com/2hal/common-harness-lib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-harness-lib-0.0.18-1.src.rpm
checksum_type: sha256
description:
  [H2H Toolkit] Common python library for harness functions within task docker images.



  Create object with `CommonHarnessLib()`. To disable s3 features, use the `disable_s3=False` flag.

  Methods:
  * S3:
    * **handle_s3_exception(err: Exception)**: Handle's common s3 errors.
    * **get_object_content(bucket_name: str, object_key: str)**: Get's a s3 object content as a string.
    * **download_wordlists(wordlist_keys: List[str])**: Downloads a list of wordlists from s3 and combines them as one file.
  * System:
    * **run_command(command: List[str])**: Run a command (i.e. ["echo", "hello world"])
  * Validation:
    * **validate_dict({"firstname": str, "age": int})**: Validates that a dict matches required type entries


pkgId: 24fa89dc4084512ebe295fd344d8f793fe1deac42a4445100e0a6c29d1d95d93
name: python-common-image-tools
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/common-image-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-image-tools-0.3.3-1.src.rpm
checksum_type: sha256
description:
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Coverage Status](/reports/coverage/coverage-badge.svg?dummy=8484744)](./reports/coverage/index.html)



  common_image_tools is a repository containing a curated collection of commonly used image manipulation functions for
  computer vision projects. These tools provide a set of handy functions for performing various image processing tasks,
  such as resizing, cropping, filtering, and more.



  - **Resizing**: Easily resize images to desired dimensions.
  - **Cropping**: Crop images to focus on specific regions.
  - **Filtering**: Apply various filters to enhance or modify images.
  - **Conversion**: Convert images between different formats.
  - **Visualization**: Tools for visualizing image data.
  - ...



  To install common_image_tools, run the following command:

  ```bash
  pip install common-image-tools
  ```

  or using poetry:

  ```bash
  poetry add common-image-tools
  ```

















  Contributions are welcome! If you have any suggestions, improvements, or new features to add, please open an issue or
  submit a pull request. Make sure to follow the existing coding style and include appropriate tests.



  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 86e11fcde4d97606c89b5582058ae5e4322f3b371d19d24a618a1deecba0bce2
name: python-common-osint-model
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Converting data from services like BinaryEdge, Censys and Shodan to a common data model.
url: https://github.com/3c7/common-osint-model
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-osint-model-0.6.0-1.src.rpm
checksum_type: sha256
description:
  {
    "443.port": 443,
    "443.banner": "HTTP/1.1 301 Moved Permanently\r\nContent-Length: 0\r\nLocation: https://github.com/\r\n\r\n",
    "443.md5": "d402a6212741f3690b4fa1e46d9bd8b6",
    "443.sha1": "a24eb4ba0332776d38050a7b41d0366742dbf262",
    "443.sha256": "5fbe0315395986d131e4948888987319e88e3e1da6c5460e8a0bf8b7a1e639f0",
    "443.murmur": "-1655207803",
    "443.first_seen": "2021-08-20T16:10:27.656097",
    "443.last_seen": "2021-08-20T16:10:27.656099",
    "443.timestamp": "2021-08-16T20:42:40.325940",
    "443.http.headers.Content-Length": "0",
    "443.http.headers.Location": "https://github.com/",
    "443.http.content.raw": "",
    "443.http.content.length": 0,
    "443.http.content.md5": "d41d8cd98f00b204e9800998ecf8427e",
    "443.http.content.sha1": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
    "443.http.content.sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
    "443.http.content.murmur": "0",
    "443.tls.certificate.issuer.dn": "C=US, O=DigiCert, Inc., CN=DigiCert High Assurance TLS Hybrid ECC SHA256 2020 CA1",
    "443.tls.certificate.issuer.country": "US",
    "443.tls.certificate.issuer.organization": "DigiCert, Inc.",
    "443.tls.certificate.issuer.common_name": "DigiCert High Assurance TLS Hybrid ECC SHA256 2020 CA1",
    "443.tls.certificate.subject.dn": "C=US, ST=California, L=San Francisco, O=GitHub, Inc., CN=github.com",
    "443.tls.certificate.subject.country": "US",
    "443.tls.certificate.subject.state": "California",
    "443.tls.certificate.subject.locality": "San Francisco",
    "443.tls.certificate.subject.organization": "GitHub, Inc.",
    "443.tls.certificate.subject.common_name": "github.com",
    "443.tls.certificate.issued": "2021-03-25T00:00:00",
    "443.tls.certificate.expires": "2022-03-30T23:59:59",
    "443.tls.certificate.expired": false,
    "443.tls.certificate.alternative_names": [
      "www.github.com",
      "github.com"
    ],
    "443.tls.certificate.pem": "-----BEGIN CERTIFICATE-----\nMIIFBjCCBK2gAwIBAgIQDovzdw2S0Zbwu2H5PEFmvjAKBggqhkjOPQQDAjBnMQsw\nCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xPzA9BgNVBAMTNkRp\nZ2lDZXJ0IEhpZ2ggQXNzdXJhbmNlIFRMUyBIeWJyaWQgRUNDIFNIQTI1NiAyMDIw\nIENBMTAeFw0yMTAzMjUwMDAwMDBaFw0yMjAzMzAyMzU5NTlaMGYxCzAJBgNVBAYT\nAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2Nv\nMRUwEwYDVQQKEwxHaXRIdWIsIEluYy4xEzARBgNVBAMTCmdpdGh1Yi5jb20wWTAT\nBgcqhkjOPQIBBggqhkjOPQMBBwNCAASt9vd1sdNJVApdEHG93CUGSyIcoiNOn6H+\nudCMvTm8DCPHz5GmkFrYRasDE77BI3q5xMidR/aW4Ll2a1A2ZvcNo4IDOjCCAzYw\nHwYDVR0jBBgwFoAUUGGmoNI1xBEqII0fD6xC8M0pz0swHQYDVR0OBBYEFCexfp+7\nJplQ2PPDU1v+MRawux5yMCUGA1UdEQQeMByCCmdpdGh1Yi5jb22CDnd3dy5naXRo\ndWIuY29tMA4GA1UdDwEB/wQEAwIHgDAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYB\nBQUHAwIwgbEGA1UdHwSBqTCBpjBRoE+gTYZLaHR0cDovL2NybDMuZGlnaWNlcnQu\nY29tL0RpZ2lDZXJ0SGlnaEFzc3VyYW5jZVRMU0h5YnJpZEVDQ1NIQTI1NjIwMjBD\nQTEuY3JsMFGgT6BNhktodHRwOi8vY3JsNC5kaWdpY2VydC5jb20vRGlnaUNlcnRI\naWdoQXNzdXJhbmNlVExTSHlicmlkRUNDU0hBMjU2MjAyMENBMS5jcmwwPgYDVR0g\nBDcwNTAzBgZngQwBAgIwKTAnBggrBgEFBQcCARYbaHR0cDovL3d3dy5kaWdpY2Vy\ndC5jb20vQ1BTMIGSBggrBgEFBQcBAQSBhTCBgjAkBggrBgEFBQcwAYYYaHR0cDov\nL29jc3AuZGlnaWNlcnQuY29tMFoGCCsGAQUFBzAChk5odHRwOi8vY2FjZXJ0cy5k\naWdpY2VydC5jb20vRGlnaUNlcnRIaWdoQXNzdXJhbmNlVExTSHlicmlkRUNDU0hB\nMjU2MjAyMENBMS5jcnQwDAYDVR0TAQH/BAIwADCCAQUGCisGAQQB1nkCBAIEgfYE\ngfMA8QB2ACl5vvCeOTkh8FZzn2Old+W+V32cYAr4+U1dJlwlXceEAAABeGq/vRoA\nAAQDAEcwRQIhAJ7miER//DRFnDJNn6uUhgau3WMt4vVfY5dGigulOdjXAiBIVCfR\nxjK1v4F31+sVaKzyyO7JAa0fzDQM7skQckSYWQB3ACJFRQdZVSRWlj+hL/H3bYbg\nIyZjrcBLf13Gg1xu4g8CAAABeGq/vTkAAAQDAEgwRgIhAJgAEkoJQRivBlwo7x67\n3oVsf1ip096WshZqmRCuL/JpAiEA3cX4rb3waLDLq4C48NSoUmcw56PwO/m2uwnQ\nprb+yh0wCgYIKoZIzj0EAwIDRwAwRAIgK+Kv7G+/KkWkNZg3PcQFp866Z7G6soxo\na4etSZ+SRlYCIBSiXS20Wc+yjD111nPzvQUCfsP4+DKZ3K+2GKsERD6d\n-----END CERTIFICATE-----\n",
    "443.tls.certificate.md5": "a07ee2076a6e392e1e96481e99ba094b",
    "443.tls.certificate.sha1": "8463b3a92912ccfd1d314705989bec139937d0d7",
    "443.tls.certificate.sha256": "0ae384bfd4dde9d13e50c5857c05a442c93f8e01445ee4b34540d22bd1e37f1b",
    "443.source": "shodan",
    "80.port": 80,
    "80.banner": "HTTP/1.1 301 Moved Permanently\r\nContent-Length: 0\r\nLocation: https://140.82.121.4/\r\n\r\n",
    "80.md5": "86c9c13165fff2c41db667dd1f6500db",
    "80.sha1": "8ecee0314c63c092d449b0d37d00f0ff62448dd1",
    "80.sha256": "715fd6cec44f12bb5e59f57bf9a1691708a5a2d2ef253399358ac3ff88f47781",
    "80.murmur": "1256792822",
    "80.first_seen": "2021-08-20T16:10:27.656097",
    "80.last_seen": "2021-08-20T16:10:27.656099",
    "80.timestamp": "2021-08-16T20:42:38.012570",
    "80.http.headers.Content-Length": "0",
    "80.http.headers.Location": "https://140.82.121.4/",
    "80.http.content.raw": "",
    "80.http.content.length": 0,
    "80.http.content.md5": "d41d8cd98f00b204e9800998ecf8427e",
    "80.http.content.sha1": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
    "80.http.content.sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
    "80.http.content.murmur": "0",
    "80.source": "shodan",
    "9418.port": 9418,
    "9418.banner": "0020ERR \n  Repository not found.",
    "9418.md5": "fc79d10176a28462bc071909fb99d59e",
    "9418.sha1": "0df752dd6b3d3a461f30691ff89ee67ef3dd21b1",
    "9418.sha256": "5f355dafa7999d06265bb17e949b76eab283e9966ef8e27908c4e1058a891121",
    "9418.murmur": "-1636861384",
    "9418.first_seen": "2021-08-20T16:10:27.656097",
    "9418.last_seen": "2021-08-20T16:10:27.656099",
    "9418.timestamp": "2021-08-12T02:10:13.136596",
    "9418.source": "shodan",
    "22.port": 22,
    "22.banner": "SSH-2.0-babeld-968490c5\nKey type: ssh-rsa\nKey: AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PH\nkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETY\nP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoW\nf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lG\nHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==\nFingerprint: 16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48\n\nKex Algorithms:\n\tcurve25519-sha256\n\tcurve25519-sha256@libssh.org\n\tecdh-sha2-nistp256\n\tecdh-sha2-nistp384\n\tecdh-sha2-nistp521\n\tdiffie-hellman-group-exchange-sha256\n\nServer Host Key Algorithms:\n\trsa-sha2-512\n\trsa-sha2-256\n\tssh-rsa\n\tssh-dss\n\nEncryption Algorithms:\n\tchacha20-poly1305@openssh.com\n\taes256-gcm@openssh.com\n\taes128-gcm@openssh.com\n\taes256-ctr\n\taes192-ctr\n\taes128-ctr\n\taes256-cbc\n\taes192-cbc\n\taes128-cbc\n\nMAC Algorithms:\n\thmac-sha2-512-etm@openssh.com\n\thmac-sha2-256-etm@openssh.com\n\thmac-sha2-512\n\thmac-sha2-256\n\thmac-sha1-etm@openssh.com\n\thmac-sha1\n\nCompression Algorithms:\n\tnone\n\n",
    "22.md5": "d652c84a47553c66047cf67e51f1345a",
    "22.sha1": "679cc04ce70413f639351328bb2f0a70545d0cb6",
    "22.sha256": "2431ffe5d8acbb77b6db91ee84f75baa0422d56947e0b85331dde2560e5454d5",
    "22.murmur": "1023136053",
    "22.first_seen": "2021-08-20T16:10:27.656097",
    "22.last_seen": "2021-08-20T16:10:27.656099",
    "22.timestamp": "2021-08-03T21:10:29.568093",
    "22.ssh.algorithms.encryption": [
      "chacha20-poly1305@openssh.com",
      "aes256-gcm@openssh.com",
      "aes128-gcm@openssh.com",
      "aes256-ctr",
      "aes192-ctr",
      "aes128-ctr",
      "aes256-cbc",
      "aes192-cbc",
      "aes128-cbc"
    ],
    "22.ssh.algorithms.key_exchange": [
      "curve25519-sha256",
      "curve25519-sha256@libssh.org",
      "ecdh-sha2-nistp256",
      "ecdh-sha2-nistp384",
      "ecdh-sha2-nistp521",
      "diffie-hellman-group-exchange-sha256"
    ],
    "22.ssh.algorithms.mac": [
      "hmac-sha2-512-etm@openssh.com",
      "hmac-sha2-256-etm@openssh.com",
      "hmac-sha2-512",
      "hmac-sha2-256",
      "hmac-sha1-etm@openssh.com",
      "hmac-sha1"
    ],
    "22.ssh.algorithms.key_algorithms": [
      "rsa-sha2-512",
      "rsa-sha2-256",
      "ssh-rsa",
      "ssh-dss"
    ],
    "22.ssh.algorithms.compression": [
      "none"
    ],
    "22.ssh.key.raw": "AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PH\nkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETY\nP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoW\nf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lG\nHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==\n",
    "22.ssh.key.type": "ssh-rsa",
    "22.ssh.key.md5": "1627aca576282d36631b564debdfa648",
    "22.ssh.key.sha1": "bf6b6825d2977c511a475bbefb88aad54a92ac73",
    "22.ssh.key.sha256": "9d385b83a9175292561a5ec4d4818e0aca51a264f17420112ef88ac3a139498f",
    "22.ssh.key.murmur": "-388505952",
    "22.source": "shodan"
  }
  ```


pkgId: 139bc7286669454b328e27cd4607c87525fb9b2761e9173bae849e04e476a3ac
name: python-common-patterns
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Python Common Patterns
url: https://github.com/VisionNetworkProject/python-common-patterns
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-patterns-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](http://img.shields.io/pypi/v/common-patterns.svg)](https://pypi.python.org/pypi/common-patterns/)

  Common Patterns




  ``` console
  $ pip3 install common-patterns
  ```




  ``` python
  import common-patterns
  ```


pkgId: 610a6c55fa535b7b0e8d760836de5f54730c8c00579ebc4d90e9d83e1d604657
name: python-common-qml
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Common QML modules.
url: https://github.com/twyleg/common_qml
rpm_license: GPL 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-qml-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/twyleg/common_qml/actions/workflows/tests.yaml/badge.svg)]()
  [![GitHub latest commit](https://badgen.net/github/last-commit/twyleg/common_qml)](https://GitHub.com/twyleg/common_qml/commit/)
  [![PyPI download month](https://img.shields.io/pypi/dm/common-qml)](https://pypi.python.org/pypi/common-qml/)
  [![PyPi version](https://badgen.net/pypi/v/common-qml/)](https://pypi.org/project/common-qml)
  [![Documentation Status](https://readthedocs.org/projects/common-qml/badge/?version=latest)](http://common-qml.readthedocs.io/?badge=latest)




  Ipsum Lorem



  Add the following secrets for GitHub Actions:

  * PYPI_API_TOKEN



  All examples can be found in the [examples/](https://github.com/twyleg/common_qml/tree/master/examples) directory.


pkgId: e686061b3dd29aad8bf11ed6cee915214872543736ef35d8a3b75368374a51fc
name: python-common-regression-issues
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A repo to store information about and simulations of common regression issues
url: https://github.com/redam94/common_regression_issues
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-regression-issues-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  [![](https://github.com/redam94/common_regression_issues/actions/workflows/test.yaml/badge.svg)](https://github.com/redam94/common_regression_issues/actions/workflows/test.yaml)

  Please hop on over to the
  [site](https://redam94.github.io/common_regression_issues), there I
  cover several topics that I’ve encountered while modelling. Please feel
  free to raise an
  [issue](https://github.com/redam94/common_regression_issues/issues) if
  there is a topic that you think should be discussed, or if there are any
  changes/clarifications/errors you find on the
  [site](https://redam94.github.io/common_regression_issues).


pkgId: ea4a3dd87335e39a8463cfdd2e9820476c9eedc5d6d42c72ed34467efae027b2
name: python-common-utility-pepe
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: korean pepe lover
url: https://github.com/yourusername/CommonUtility
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-utility-pepe-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ```bash
  python -m venv myenv
  source myenv/bin/activate  # macOS/Linux

  pip install -r requirements.txt
  ```







  ```python
  from common_utility_pepe.slack_pepe import SlackPepe

  slack_pepe_webhook = SlackPepe.from_webhook(
      webhook_url="your_web_hook_url"
  )
  slack_pepe_webhook.send_slack_message(title="go away")
  ```



  ```python
  from common_utility_pepe.slack_pepe import SlackPepe

  slack_pepe_bot = SlackPepe.from_bot(
      channel="your_channel_id",
      bot_token="your_bot_token"
  )
  slack_pepe_bot.send_slack_message(title="hi there")

  slack_pepe_bot.update_slack_message(timestamp="your_timestamp", title="it's fake")
  ```


pkgId: 8d7a19a1224c12dbb167be78a0e871ed2b3f202be836d87086c1da60ec47e1ae
name: python-common-utils-py
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: 🐳 Library including all the common functionalities used in Python projects
url: https://github.com/nevermined-io/common-utils-py
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-utils-py-1.0.4-1.src.rpm
checksum_type: sha256
description:
  [![banner](https://raw.githubusercontent.com/nevermined-io/assets/main/images/logo/banner_logo.png)](https://nevermined.io)


  Provides common functions to interact with Nevermined ecosystem

  [![PyPI](https://img.shields.io/pypi/v/common-utils-py.svg)](https://pypi.org/project/common-utils-py/)


  * DID and DDO
    * DID format: 'did:nv:<32bytes-hex-representation>
    * DID is the universal identifier for assets in the Nevermined network
    * DDO is the json document that
  * DID resolver
    * Given a valid did, returns the associated DDO document which define
      the asset metadata and other services offered for the asset
  * Metadata
  * Service Agreements


  This project is based in the [Ocean Protocol Common-utils-py](https://github.com/oceanprotocol/common-utils-py). It keeps the same Apache v2 License and adds some improvements.




  ```text
  Copyright 2020 Keyko GmbH.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

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


pkgId: c1ebf9bfe687f908820315bdc323baf7dea574d098703083cf482b713836a701
name: python-common-wrangler
arch: src
version: 0.3.8.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/common-wrangler/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-common-wrangler-0.3.8.1-1.src.rpm
checksum_type: sha256
description:
  Scripts for file and data manipulation, as well as common scripts used in this project as well as
  gaussian_wrangler, ligninkmc, and md_wrangler


pkgId: fff2df5b60a4c9629c2e8a24edd45c043f8f1215c230a9abe858593c1dab671b
name: python-commoncode
arch: src
version: 32.0.0
epoch: 0
release: 1
summary: Set of common utilities, originally split from ScanCode
url: https://github.com/aboutcode-org/commoncode
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commoncode-32.0.0-1.src.rpm
checksum_type: sha256
description:
  - license: Apache-2.0
  - copyright: copyright (c) nexB. Inc. and others
  - homepage_url: https://github.com/aboutcode-org/commoncode
  - keywords: utilities, scancode-toolkit, commoncode
  Commoncode provides a set of common functions and utilities for handling various things like paths,
  dates, files and hashes. It started as library in scancode-toolkit.
  Visit https://aboutcode.org and https://github.com/aboutcode-org/ for support and download.
  To install this package use::
      pip install commoncode
  Alternatively, to set up a development environment::
      ./configure --dev
      source venv/bin/activate
  To run unit tests::
      pytest -vvs -n 2
  To clean up development environment::
      ./configure --clean


pkgId: 5461e68f5a7b10242b107eed90527570be5ae98bdac7c40d1390322cedc486ee
name: python-commondtools
arch: src
version: 0.0.26
epoch: 0
release: 1
summary: Common D-tools.
url: https://github.com/M0Rph3U56031769/commondtools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commondtools-0.0.26-1.src.rpm
checksum_type: sha256
description:
  ![CodeQL](https://github.com/M0Rph3U56031769/commondtools/workflows/CodeQL/badge.svg)

  ![Lines of code](https://img.shields.io/tokei/lines/github/M0Rph3U56031769/commondtools)

  ![GitHub top language](https://img.shields.io/github/languages/top/M0Rph3U56031769/commondtools)
  ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/M0Rph3U56031769/commondtools)
  ![GitHub all releases](https://img.shields.io/github/downloads/M0Rph3U56031769/commondtools/total)
  ![GitHub](https://img.shields.io/github/license/M0Rph3U56031769/commondtools)
  ![GitHub Repo stars](https://img.shields.io/github/stars/M0Rph3U56031769/commondtools?style=social)
  ![GitHub watchers](https://img.shields.io/github/watchers/M0Rph3U56031769/commondtools?style=social)
  ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/M0Rph3U56031769/commondtools)
  ![GitHub last commit](https://img.shields.io/github/last-commit/M0Rph3U56031769/commondtools)

  ![PyPI - Downloads](https://img.shields.io/pypi/dm/commondtools)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/commondtools)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/commondtools)
  ![PyPI - Format](https://img.shields.io/pypi/format/commondtools)

  Hit counters:

  ![GitHub search hit counter](https://img.shields.io/github/search/M0Rph3U56031769/commondtools/csv)
  ![GitHub search hit counter](https://img.shields.io/github/search/M0Rph3U56031769/commondtools/commondtools)
  ![GitHub search hit counter](https://img.shields.io/github/search/M0Rph3U56031769/commondtools/network)


  This is a simple package for common usage.

  network, file handling and parallel functions

  https://m0rph3u56031769.github.io/commondtools/

  https://pypi.org/project/commondtools/

  https://github.com/M0Rph3U56031769/commondtools


pkgId: a8b4e516b1e0f83707ee9b652610e736ffb8720f9f4691f5637548ca769546ba
name: python-commonmark
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Python parser for the CommonMark Markdown spec
url: https://github.com/rtfd/commonmark.py
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonmark-0.9.1-1.src.rpm
checksum_type: sha256
description:
  commonmark.py is a pure Python port of `jgm <https://github.com/jgm>`__'s
  `commonmark.js <https://github.com/jgm/commonmark.js>`__, a
  Markdown parser and renderer for the
  `CommonMark <http://commonmark.org>`__ specification, using only native
  modules. Once both this project and the CommonMark specification are
  stable we will release the first ``1.0`` version and attempt to keep up
  to date with changes in ``commonmark.js``.
  commonmark.py is tested against the CommonMark spec with Python versions
  2.7, 3.4, 3.5, 3.6, and 3.7.
  **Current version:** 0.9.1
  |Pypi Link| |Build Status| |Doc Link|


pkgId: 69d7ae59da47eb0d84d4ccab7eaeb422cade77dd0dacbd04dff2c386deadfd8b
name: python-commonmark-slack
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Convert CommonMark Markdown to Slack Markdown
url: https://github.com/klm1/commonmarkslack
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonmark-slack-1.0.0-1.src.rpm
checksum_type: sha256
description:
  CommonMark-Slack extends the [commonmark.py](https://github.com/readthedocs/commonmark.py) library to add rendering of the
  [Slack](https://slack.com/) flavor of Markdown. This can be handy if you are already using [standard Markdown](https://commonmark.org/)
  for another purpose and would like to also produce Slack output from the same source. CommonMark-slack also allows for producing
  plaintext from standard Markdown, useful for the areas of Slack that use unadorned text.



  You can install CommonMark-Slack from [PyPI](https://pypi.org/project/commonmark-slack/):

      pip install commonmark-slack

  The commonmark-slack package is supported by Python 3.6 and above.



  ```
  import commonmarkslack
  parser = commonmarkslack.Parser()
  ast = parser.parse("Hello *World*")

  renderer = commonmark.SlackRenderer()
  slack_md = renderer.render(ast)
  print(slack_md) # Hello _World_

  renderer = commonmarkslack.PlainTextRenderer()
  plain_text = renderer.render(ast)
  print(plain_text) # Hello World
  ```


pkgId: d107f528e882829568b1f3917a0e6d57048f027b4a68df1f490c333baf631109
name: python-commonmeta-py
arch: src
version: 0.50
epoch: 0
release: 1
summary: Library for conversions to/from the Commonmeta scholarly metadata format
url: https://python.commonmeta.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonmeta-py-0.50-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/570526578.svg)](https://zenodo.org/doi/10.5281/zenodo.8340374)
  [![Build](https://github.com/front-matter/commonmeta-py/actions/workflows/build.yml/badge.svg)](https://github.com/front-matter/commonmeta-py/actions/workflows/build.yml)
  [![PyPI version](https://img.shields.io/pypi/v/commonmeta-py.svg)](https://pypi.org/project/commonmeta-py/)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=front-matter_commonmeta-py&metric=coverage)](https://sonarcloud.io/summary/new_code?id=front-matter_commonmeta-py)
  [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=front-matter_commonmeta-py&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=front-matter_commonmeta-py)
  [![docs](https://img.shields.io/badge/docs-passing-blue)](https://python.commonmeta.org)
  ![GitHub](https://img.shields.io/github/license/front-matter/commonmeta-py?logo=MIT)



  commonmeta-py is a Python library to implement Commonmeta, the common Metadata Model for Scholarly Metadata. Use commonmeta-py to convert scholarly metadata, in a variety of formats, listed below. Commonmeta-py is work in progress, the first release on PyPi (version 0.5.0) was on February 16, 2023. Up until version 0.5.1, the library was called talbot. Commonmeta-py is modelled after the [commonmeta-ruby ruby gem](https://github.com/front-matter/commonmeta-ruby).

  commonmeta-py uses semantic versioning. Currently, its major version number is still at 0, meaning the API is not yet stable, and breaking changes are expected in the internal API and commonmeta JSON format.



  Stable version

      pip (or pip3) install commonmeta-py

  Dev version

      pip install git+https://github.com/front-matter/commonmeta-py.git#egg=commonmeta-py



  Commometa-py reads and/or writes these metadata formats:

  | Format                                                                                           | Name          | Content Type                           | Read    | Write   |
  | ------------------------------------------------------------------------------------------------ | ------------- | -------------------------------------- | ------- | ------- |
  | Commonmeta  | commonmeta    | application/vnd.commonmeta+json        | yes     | yes     |
  | [CrossRef XML](https://www.crossref.org/schema/documentation/unixref1.1/unixref1.1.html) | crossref_xml      | application/vnd.crossref.unixref+xml   | yes | yes |
  | [Crossref](https://api.crossref.org)                                                             | crossref | application/vnd.crossref+json          | yes     | n/a     |
  | [DataCite](https://api.datacite.org/)                                                            | datacite | application/vnd.datacite.datacite+json | yes     | yes |
  | [Schema.org (in JSON-LD)](http://schema.org/)                                                    | schema_org    | application/vnd.schemaorg.ld+json      | yes     | yes     |
  | [RDF XML](http://www.w3.org/TR/rdf-syntax-grammar/)                                              | rdf_xml       | application/rdf+xml                    | no      | later   |
  | [RDF Turtle](http://www.w3.org/TeamSubmission/turtle/)                                           | turtle        | text/turtle                            | no      | later   |
  | [CSL-JSON](https://citationstyles.org/)                                                     | csl      | application/vnd.citationstyles.csl+json | yes | yes     |
  | [Formatted text citation](https://citationstyles.org/)                                           | citation      | text/x-bibliography                    | n/a     | yes     |
  | [Codemeta](https://codemeta.github.io/)                                                          | codemeta      | application/vnd.codemeta.ld+json       | yes | later |
  | [Citation File Format (CFF)](https://citation-file-format.github.io/)                            | cff           | application/vnd.cff+yaml               | yes | later |
  | [JATS](https://jats.nlm.nih.gov/)                                                                | jats          | application/vnd.jats+xml               | later   | later   |
  | [CSV](ttps://en.wikipedia.org/wiki/Comma-separated_values)                                       | csv           | text/csv                               | no      | later   |
  | [BibTex](http://en.wikipedia.org/wiki/BibTeX)                                                    | bibtex        | application/x-bibtex                   | later | yes     |
  | [RIS](http://en.wikipedia.org/wiki/RIS_(file_format))                                            | ris           | application/x-research-info-systems    | yes   | yes     |
  | [InvenioRDM](https://inveniordm.docs.cern.ch/reference/metadata/)                                | inveniordm    | application/vnd.inveniordm.v1+json     | yes   | yes     |
  | [JSON Feed](https://www.jsonfeed.org/)                                                           | json_feed_item     | application/feed+json    | yes | later     |

  _commonmeta_: the Commonmeta format is the native format for the library and used internally.
  _Planned_: we plan to implement this format for the v1.0 public release.
  _Later_: we plan to implement this format in a later release.



  Documentation (work in progress) for using the library is available at the [commonmeta-py Documentation](https://python.commonmeta.org/) website and includes several interactive Jupyter Notebooks .



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

  License: [MIT](https://github.com/front-matter/commonmeta-py/blob/main/LICENSE)


pkgId: 0f6196ac7480c460b0e485970fb1127db0076cd1e8d89fc2a9d4a22bb4b81925
name: python-commonmethods
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://pypi.org/project/commonmethods/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonmethods-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  This library contains some common methods that you don't wanna rewrite every time you make a new project.

description:
  'commonmethods' is a python library that contains methods that I use often, and don't want to rewrite for every project.


  To install the tools needed to develop and run tests, run the following in your virtualenv:

  ```bash
  $ pip install -e .[dev]
  ```


pkgId: 8e24be2d7642082cedc073a3c87a3abbdcf9ce10e0cdcd358100a382825834bc
name: python-commonnexus
arch: src
version: 1.9.2
epoch: 0
release: 1
summary: A nexus (phylogenetics) file reader and writer (.nex, .trees)
url: https://github.com/dlce-eva/commonnexus
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonnexus-1.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/dlce-eva/commonnexus/workflows/tests/badge.svg)](https://github.com/dlce-eva/commonnexus/actions?query=workflow%3Atests)
  [![Documentation Status](https://readthedocs.org/projects/commonnexus/badge/?version=latest)](https://commonnexus.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://badge.fury.io/py/commonnexus.svg)](https://pypi.org/project/commonnexus)

  This package provides functionality to read and write the NEXUS file format as specified in

  > Maddison, Swofford, and Maddison (1997). "NEXUS: An extensible file format for systematic information". Systematic Biology. 46 (4): 590–621. [doi:10.1093/sysbio/46.4.590](https://doi.org/10.1093/sysbio/46.4.590)

  Rather than trying to rip out relevant portions of a NEXUS file as quickly as possible, the implementation
  in `commonnexus` tries to do "the right thing" according to the specification, i.e. parse a file token by
  token. Thus, we sacrifice speed for correctness and the ability to support weird edge cases like

  > Comments do not break tokens. Thus, `AssuMP[comment]TiONS` is processed as `ASSUMPTIONS`.




  Install `commonnexus` from [PyPI](https://pypi.org/project/commonnexus):
  ```shell
  pip install commonnexus
  ```




  `commonnexus` provides a [Python API](#python-api) as well as a [shell command](#command-line-usage)
  to manipulate (the data in) NEXUS files.

  In particular, it allows reading NEXUS

  ```python
  >>> from commonnexus import Nexus
  >>> nex = Nexus.from_file('docs/characters.nex')
  >>> nex.CHARACTERS.get_matrix()['t1'].values()
  odict_values(['1', '0', '0', '1', '0', '1', '0', '0', '0', '0'])
  ```

  and writing NEXUS

  ```python
  >>> from commonnexus import Nexus
  >>> from commonnexus.blocks import Data
  >>> nex = Nexus.from_file('docs/characters.nex')
  >>> print(Nexus.from_blocks(Data.from_data(nex.CHARACTERS.get_matrix())))

  BEGIN DATA;
  DIMENSIONS NCHAR=10;
  FORMAT DATATYPE=STANDARD MISSING=? GAP=- SYMBOLS="01";
  MATRIX
  t1 1001010000
  t2 0101000100
  t3 0011101010
  t4 0001100001
  t5 0001100001
  ;
  END;
  ```




  Installing the `commonnexus` package will also install a command line interface `commonnexus`, which provides several
  sub-commands to manipulate NEXUS files.

  Run `commonnexus -h` to get an overview of available sub-commands or find detailed documentation
  with examples [on ReadTheDocs](https://commonnexus.readthedocs.io/en/latest/cli.html).




  The Python API tries to convert NEXUS constructs to appropriate Python objects, e.g.
  - NEXUS content is a `list` of `Command` objects,
  - missing states in a CHARACTERS MATRIX are conveyed as `None` values, etc.

  This allows for dealing with NEXUS data in a way that is abstracted from the NEXUS formatting
  conventions

  For a detailed documentation of the Python API, refer to the
  [docs on ReadTheDocs](https://commonnexus.readthedocs.io/en/latest/index.html).




  - https://doi.org/10.1093/sysbio/46.4.590
  - https://github.com/dlce-eva/python-nexus
  - http://wiki.christophchamp.com/index.php?title=NEXUS_file_format


pkgId: 0b957dbd2b3feb627ac8fc759e6f0b689fb41aac734b29a1a7872d9a99497aa5
name: python-commonpy
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: Assortment of Python helper functions and utility classes
url: https://github.com/caltechlibrary/commonpy
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonpy-1.13.0-1.src.rpm
checksum_type: sha256
description:
  This is a collection of common utility functions and classes that we at the Caltech Library have found useful in our other Python projects.
  [![Latest release](https://img.shields.io/github/v/release/caltechlibrary/commonpy.svg?style=flat-square&color=b44e88&label=Latest%20release)](https://github.com/caltechlibrary/commonpy/releases)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg?style=flat-square)](https://choosealicense.com/licenses/bsd-3-clause)
  [![Python](https://img.shields.io/badge/Python-3.6+-brightgreen.svg?style=flat-square)](http://shields.io)
  [![PyPI](https://img.shields.io/pypi/v/commonpy.svg?style=flat-square&color=orange&label=PyPI)](https://pypi.org/project/commonpy/)


pkgId: 274182cb21494c381faddb7e94e2cc2bfe9257773e13af62014f1140e8c10d77
name: python-commonregex-improved
arch: src
version: 1.0.2
epoch: 0
release: 1
url: https://github.com/brootware/commonregex-improved
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonregex-improved-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  An improved version of original commonregex. Find all dates, times, emails, phone numbers, links, emails, ip addresses, prices, bitcoin address, and more in a string.

description:
  <br><br>

  <h1 align="center">CommonRegex Improved (crim)</h1>

  <p align="center">
    <a href="/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
    <!-- <img alt="PyPI - Downloads" src="https://pepy.tech/badge/commonregex-improved/month"> -->
     <img alt="PyPI - Downloads" src="https://pepy.tech/badge/commonregex-improved">
     <a href="https://twitter.com/brootware"><img src="https://img.shields.io/twitter/follow/brootware?style=social" alt="Twitter Follow"></a>
     <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/commonregex-improved"> <img alt="PyPI" src="https://img.shields.io/pypi/v/commonregex-improved">
     <a href="https://sonarcloud.io/summary/new_code?id=brootware_commonregex-improved"><img src="https://sonarcloud.io/api/project_badges/measure?project=brootware_commonregex-improved&metric=alert_status" alt="reliability rating"></a>
     <img alt="GitHub Workflow Status" src="https://img.shields.io/github/workflow/status/brootware/commonregex-improved/ci.yml?branch=main">
  </p>

  <p align="center">
    An improved version of commonly used regular expressions in Python
  </p>

  <br><br>

  > Inspired by and improved upon [CommonRegex](https://github.com/madisonmay/CommonRegex)

  This is a collection of commonly used regular expressions. This library provides a simple API interface to match the strings corresponding to specified patterns.



  ```bash
  pip install --upgrade commonregex-improved
  ```



  ```python
  import crim as CommonRegex

  text = "John, please get that article on www.linkedin.com to me by 5:00PM on Jan 9th 2012. 4:00 would be ideal, actually or 5:30 P.M. If you have any questions, You can reach me at (519)-236-2723x341 or get in touch with my associate at harold_smith@gmail.com. You can find my ip address at 127.0.0.1 or at 64.248.67.225. I also have a secret protected with md5 8a2292371ee60f8212096c06fe3335fd. The internal webpage to get the article from is https://internal.sharepoint.edu.au"

  date_list = CommonRegex.dates(text)

  time_list = CommonRegex.times(text)

  url_list = CommonRegex.links(text)

  phone_list = CommonRegex.phones_with_exts(text)

  ip_list = CommonRegex.ips(text)

  email_list = CommonRegex.emails(text)

  md5_list = CommonRegex.md5_hashes(text)

  ```



  [CommonRegex](https://github.com/madisonmay/CommonRegex) is awesome!

  So why re-implement the popular original commonregex project? The API calls to each of the regular expressions are really slow.

  It takes 12 seconds for a total of 2999 calls to Dates function in the original version of CommonRegex. While the improved version of CommonRegex with the same number of calls merely takes 2 seconds.

  ![improved](./benchmark/benchmark.png)

  You can find more detailed results about [original](./benchmark/original_cregex_result.pdf) and [improved](./benchmark/cregex_improved_result.pdf) versions.



  * `dates(text: str)`
  * `times(text: str)`
  * `phones(text: str)`
  * `phones_with_exts(text: str)`
  * `links(text: str)`
  * `emails(text: str)`
  * `ipv4s(text: str)`
  * `ipv6s(text: str)`
  * `ips(text: str)`
  * `not_known_ports(text: str)`
  * `prices(text: str)`
  * `hex_colors(text: str)`
  * `credit_cards(text: str)`
  * `visa_cards(text: str)`
  * `master_cards(text: str)`
  * `btc_address(text: str)`
  * `street_addresses(text: str)`
  * `zip_codes(text: str)`
  * `po_boxes(text: str)`
  * `ssn_numbers(text: str)`
  * `md5_hashes(text: str)`
  * `sha1_hashes(text: str)`
  * `sha256_hashes(text: str)`
  * `isbn13s(text: str)`
  * `isbn10s(text: str)`
  * `mac_addresses(text: str)`
  * `iban_numbers(text: str)`
  * `git_repos(text: str)`


pkgId: fcbec6b7f1739d39de68ca3c987531baae99d377a02aa7da8eba32751fd3241b
name: python-commonroad-io
arch: src
version: 2024.2
epoch: 0
release: 1
url: https://commonroad.in.tum.de
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonroad-io-2024.2-1.src.rpm
checksum_type: sha256
summary:
  Python tool to read, write, and visualize CommonRoad scenarios and solutions for automated vehicles.

description:
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/commonroad-io.svg)](https://pypi.python.org/pypi/commonroad-io/)
  ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)
  ![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white)
  ![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)
  [![PyPI version fury.io](https://badge.fury.io/py/commonroad-io.svg)](https://pypi.python.org/pypi/commonroad-io/)
  [![PyPI download month](https://img.shields.io/pypi/dm/commonroad-io.svg?label=PyPI%20downloads)](https://pypi.python.org/pypi/commonroad-io/)
  [![PyPI download week](https://img.shields.io/pypi/dw/commonroad-io.svg?label=PyPI%20downloads)](https://pypi.python.org/pypi/commonroad-io/)
  [![PyPI license](https://img.shields.io/pypi/l/commonroad-io.svg)](https://pypi.python.org/pypi/commonroad-io/)


  Numerical experiments for motion planning of road vehicles require numerous ingredients: vehicle dynamics,
  a road network, static obstacles, dynamic obstacles and their movement over time, goal regions, a cost function, etc.
  Providing a description of the numerical experiment precise enough to reproduce it might require several pages of
  information.
  Thus, only key aspects are typically described in scientific publications, making it impossible to reproduce
  results - yet, reproducibility is an important asset of good science.

  Composable benchmarks for motion planning on roads (CommonRoad) are proposed so that numerical experiments are fully
  defined by a unique ID; all required information to reconstruct the experiment can be found on [commonroad.in.tum.de](https://commonroad.in.tum.de/).
  Each benchmark is composed of a [vehicle model](https://gitlab.lrz.de/tum-cps/commonroad-vehicle-models/blob/master/vehicleModels_commonRoad.pdf),
  a [cost function](https://gitlab.lrz.de/tum-cps/commonroad-cost-functions/blob/master/costFunctions_commonRoad.pdf),
  and a [scenario](https://commonroad.in.tum.de/scenarios/) (including goals and constraints).
  The scenarios are partly recorded from real traffic and partly hand-crafted to create dangerous situations.
  Solutions to the benchmarks can be uploaded and ranked on the CommonRoad Website.
  Learn more about the scenario specification [here](https://gitlab.lrz.de/tum-cps/commonroad-scenarios/blob/master/documentation/XML_commonRoad_2020a.pdf).



  The commonroad-io package provides methods to read, write, and visualize CommonRoad scenarios and planning problems. Furthermore, it can be used as a framework for implementing motion planning algorithms to solve CommonRoad Benchmarks and is the basis for other tools of the CommonRoad Framework.
  With commonroad-io, those solutions can be written to xml-files for uploading them on [commonroad.in.tum.de](https://commonroad.in.tum.de/).

  commonroad-io 2024.2 is compatible with CommonRoad scenarios in version 2020a and supports reading 2018b scenarios.

  The software is written in Python and tested on Linux for the Python 3.9, 3.10, 3.11 and 3.12.




  The full documentation of the API and introducing examples can be found under [https://cps.pages.gitlab.lrz.de/commonroad/commonroad-io/](https://cps.pages.gitlab.lrz.de/commonroad/commonroad-io/).

  For getting started, we recommend our [tutorials](https://commonroad.in.tum.de/commonroad-io).


  Based on commonroad-io, we have developed a list of tools supporting the development of motion-planning algorithms:

  * [Drivability Checker](https://commonroad.in.tum.de/tools/drivability-checker)
  * [CommonRoad-SUMO Interface](https://commonroad.in.tum.de/tools/sumo-interface)
  * [Scenario Designer](https://commonroad.in.tum.de/tools/scenario-designer)
  * [Vehicle Models](https://commonroad.in.tum.de/tools/model-cost-functions)
  * [Dateset Converters](https://gitlab.lrz.de/tum-cps/dataset-converters)
  * [Interactive Scenarios](https://gitlab.lrz.de/tum-cps/commonroad-interactive-scenarios)
  * [Apollo Interface](https://gitlab.lrz.de/tum-cps/commonroad-apollo-interface)



  The required dependencies for running commonroad-io are:

  * numpy>=1.13
  * scipy>=1.5.2
  * shapely>=2.0.1
  * matplotlib>=2.2.2
  * lxml>=4.2.2
  * networkx>=2.2
  * Pillow>=7.0.0
  * commonroad-vehicle-models>=2.0.0
  * rtree>=0.8.3
  * protobuf==3.20.1



  commonroad-io can be installed with::

  	pip install commonroad-io

  Alternatively, clone from our gitlab repository::

  	git clone https://gitlab.lrz.de/tum-cps/commonroad_io.git

  and add the folder commonroad-io to your Python environment.


  Compared to version 2024.1, the following features have been added or changed:


  - Github actions for ubuntu, windows, and macOS
  - Gitlab runner for arm64 ubuntu
  - Support for reading xml and protobuf byte streams
  - Support for numpy `>=2.0`
  - Adjustable zorder for dynamic obstacle & lanelet visualization


  - AreaBorder can have multiple adjacent lanelets
  - Performance regression for occupancy_set lookups in TrajectoryPrediction
  - Matplotlib `>=3.9.0` support


  - Support for Python 3.8



  Contribution (in alphabetic order by last name): Yannick Ballnath, Behtarin Ferdousi, Luis Gressenbuch, Moritz Klischat,
  Markus Koschi, Sebastian Maierhofer, Stefanie Manzinger, Christina Miller, Christian Pek, Anna-Katharina Rettinger,
  Simon Sagmeister, Moritz Untersperger, Murat Üste, Xiao Wang


  We gratefully acknowledge partial financial support by

  * DFG (German Research Foundation) Priority Program SPP 1835 Cooperative Interacting Automobiles
  * BMW Group within the Car@TUM project
  * German Federal Ministry of Economics and Technology through the research initiative Ko-HAF


  **If you use our code for research, please consider to cite our paper:**
  ```
  @inproceedings{Althoff2017a,
  	author = {Althoff, Matthias and Koschi, Markus and Manzinger, Stefanie},
  	title = {CommonRoad: Composable benchmarks for motion planning on roads},
  	booktitle = {Proc. of the IEEE Intelligent Vehicles Symposium},
  	year = {2017},
  	pages={719-726},
  	abstract = {Numerical experiments for motion planning of road vehicles require numerous components: vehicle
  	            dynamics, a road network, static obstacles, dynamic obstacles and their movement over time, goal
  	            regions, a cost function, etc. Providing a description of the numerical experiment precise enough to
  	            reproduce it might require several pages of information. Thus, only key aspects are typically described
  	            in scientific publications, making it impossible to reproduce results—yet, re- producibility is an
  	            important asset of good science. Composable benchmarks for motion planning on roads (CommonRoad) are
  	            proposed so that numerical experiments are fully defined by a unique ID; all information required to
  	            reconstruct the experiment can be found on the CommonRoad website. Each benchmark is composed by a
  	            vehicle model, a cost function, and a scenario (including goals and constraints). The scenarios are
  	            partly recorded from real traffic and partly hand-crafted to create dangerous situations. We hope that
  	            CommonRoad saves researchers time since one does not have to search for realistic parameters of vehicle
  	            dynamics or realistic traffic situations, yet provides the freedom to compose a benchmark that fits
  	            one’s needs.},
  }
  ```


pkgId: 42ce442b68f34dd8d8e227a79d6da2da8fd26a58801169aac825960bea76467a
name: python-commonvoice-utils
arch: src
version: 0.2.30
epoch: 0
release: 1
summary: Linguistic processing for languages in Common Voice
url: https://github.com/ftyers/commonvoice-utils
rpm_license: AGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-commonvoice-utils-0.2.30-1.src.rpm
checksum_type: sha256
description:
  This repository collects together basic linguistic processing data for using dataset
  dumps from the [Common Voice](commonvoice.mozilla.org/) project. It aims to provide a one-stop-shop for
  utilities and data useful in training ASR and TTS systems.



  * Phonemiser:
    * A rudimentary grapheme to phoneme (g2p) system based on either:
      * a deterministic longest-match left-to-right replacement of orthographic units; or
      * a weighted finite-state transducer
  * Validator:
    * A validation and normalisation script.
    * It checks a sentence to see if it can be converted and if possible normalises the encoding, removes punctuation and returns it
  * Alphabet:
    * The relevant alphabet of the language, appropriate for use in training ASR
  * Segmenter:
    * A deterministic sentence segmentation algorithm tuned for segmenting paragraphs from Wikipedia
  * Corpora:
    * Contains metadata for different corpora you may be interested in using with Common Voice



  The easiest way is with `pip`:

  ```bash
  $ pip install git+https://github.com/ftyers/commonvoice-utils.git
  ```





  There is also a command line tool, `covo` /ˈkəʊvəʊ/ which aims to expose much of the functionality
  through the command line. Some examples on the next lines:



  Use a Wikipedia dump to get text for a language mode in the right format:

  ```bash
  $ covo dump mtwiki-latest-pages-articles.xml.bz2 | covo segment mt | covo norm mt
  x'inhi l-wikipedija
  il-wikipedija hi mmexxija mill-fondazzjoni wikimedia fondazzjoni mingħajr fini ta' lukru li tospita proġetti oħra b'kontenut ħieles u multilingwi
  il-malti huwa l-ilsien nazzjonali tar-repubblika ta' malta
  huwa l-ilsien uffiċjali flimkien mal-ingliż kif ukoll wieħed mill-ilsna uffiċjali tal-unjoni ewropea
  ```



  Get a list of URLs for a particular language from the OPUS corpus collection:

  ```bash
  $ covo opus mt | sort -gr
  23859 documents,69.4M tokens	https://object.pouta.csc.fi/OPUS-DGT/v2019/mono/mt.txt.gz
  8665 documents,25.8M tokens	https://object.pouta.csc.fi/OPUS-JRC-Acquis/v3.0/mono/mt.txt.gz
  5388 documents,8.9M tokens	https://object.pouta.csc.fi/OPUS-JW300/v1b/mono/mt.txt.gz
  ...
  ```



  Get the grapheme to phoneme output for some arbitrary input:

  ```bash
  $ echo "euskal herrian euskaraz" | covo phon eu
  eus̺kal erian eus̺kaɾas̻

  $ echo "قايتا نىشان بەلگىلەش ئورنى ئۇيغۇرچە ۋىكىپىدىيە" | covo phon ug
  qɑjtɑ nɪʃɑn bɛlɡɪlɛʃ ornɪ ujʁurtʃɛ vɪkɪpɪdɪjɛ
  ```



  Designed for use with [Coqui STT](https://github.com/coqui-ai/STT/), converts
  to 16kHz mono-channel PCM .wav files and runs the transcripts through the validation
  step. In addition outputs `.csv` files for each of the input `.tsv` files. The
  structure of the command is:

  ```bash
  $ covo export coqui [language code] [common voice dataset directory]
  ```

  For example for Erzya, `myv`:

  ```bash
  $ covo export myv cv-corpus-8.0-2022-01-19/myv/
  Loading TSV file:  cv-corpus-8.0-2022-01-19/myv/test.tsv
    Importing mp3 files...
    Imported 292 samples.
    Skipped 2 samples that were longer than 10 seconds.
    Final amount of imported audio: 0:27:03 from 0:27:23.
    Saving new Coqui STT-formatted CSV file to:  cv-corpus-8.0-2022-01-19/myv/clips/test.csv
    Writing CSV file for train.py as:  cv-corpus-8.0-2022-01-19/myv/clips/test.csv
  ```



  Designed for use with [NVIDIA's Nemo](https://github.com/NVIDIA/NeMo), converts
  to 16kHz mono-channel PCM .wav files and runs the transcripts through the validation
  step. In addition outputs `.json` files for each of the input `.tsv` files. The
  structure of the command is:


  ```bash
  $ covo export nemo [language code] [common voice dataset directory]
  ```

  For example for Sardinian, `sc`:

  ```bash
  INFO:root:Find existing folder /tmp/cv-corpus-10.0-2022-07-04/sc/
  INFO:root:Converting mp3 to wav for /tmp/cv-corpus-10.0-2022-07-04/sc/test.tsv.
  100%|█████████████████████████████████████| 98/98 [00:00<00:00, 466.73it/s]
  INFO:root:Creating manifests...
  100%|█████████████████████████████████████| 98/98 [00:00<00:00, 94059.91it/s]
  INFO:root:Converting mp3 to wav for /tmp/cv-corpus-10.0-2022-07-04/sc/dev.tsv.
  100%|█████████████████████████████████████| 79/79 [00:00<00:00, 494.77it/s]
  INFO:root:Creating manifests...
  100%|█████████████████████████████████████| 79/79 [00:00<00:00, 100744.91it/s]
  INFO:root:Converting mp3 to wav for /tmp/cv-corpus-10.0-2022-07-04/sc/train.tsv.
  100%|█████████████████████████████████████| 200/200 [00:00<00:00, 497.96it/s]
  INFO:root:Creating manifests...
  100%|█████████████████████████████████████| 200/200 [00:00<00:00, 113836.45it/s]
  ```



  The code can also be used as a Python module, here are some examples:



  Returns an alphabet appropriate for end-to-end speech recognition.

  ```python
  >>> from cvutils import Alphabet
  >>> a = Alphabet('cv')
  >>> a.get_alphabet()
  ' -абвгдежзийклмнопрстуфхцчшщыэюяёҫӑӗӳ'
  ```



  Some miscellaneous tools for working with corpora:

  ```python
  >>> from cvutils import Corpora
  >>> c = Corpora('kpv')
  >>> c.dump_url()
  'https://dumps.wikimedia.org/kvwiki/latest/kvwiki-latest-pages-articles.xml.bz2'
  >>> c.target_segments()
  []
  >>> c = Corpora('cv')
  >>> c.target_segments()
  ['нуль', 'пӗрре', 'иккӗ', 'виҫҫӗ', 'тӑваттӑ', 'пиллӗк', 'улттӑ', 'ҫиччӗ', 'саккӑр', 'тӑххӑр', 'ҫапла', 'ҫук']
  >>> c.dump_url()
  'https://dumps.wikimedia.org/cvwiki/latest/cvwiki-latest-pages-articles.xml.bz2'
  ```



  For a given token, return an approximate broad phonemised version of it.

  ```python
  >>> from cvutils import Phonemiser
  >>> p = Phonemiser('ab')
  >>> p.phonemise('гӏапынхъамыз')
  'ʕapənqaməz'

  >>> p = Phonemiser('br')
  >>> p.phonemise("implijout")
  'impliʒut'
  ```



  For a given input sentence/utterance, the validator returns either a validated and normalised
  version of the string according to the validation rules, or `None` if the string cannot be
  validated.

  ```python
  >>> from cvutils import Validator
  >>> v = Validator('ab')
  >>> v.validate('Аллаҳ хаҵеи-ԥҳәыси иеилыхны, аҭыԥҳацәа роума иалихыз?')
  'аллаҳ хаҵеи-ԥҳәыси иеилыхны аҭыԥҳацәа роума иалихыз'

  >>> v = Validator('br')
  >>> v.validate('Ha cʼhoant hocʼh eus da gendercʼhel da implijout ar servijer-mañ ?')
  "ha c'hoant hoc'h eus da genderc'hel da implijout ar servijer-mañ"
  ```



  Mostly designed for use with Wikipedia, takes a paragraph and returns a list of the
  sentences found within it.

  ```python
  >>> from cvutils import Segmenter
  >>> s = Segmenter('br')
  >>> para = "Peurliesañ avat e kemm ar vogalennoù e c'hengerioù evit dont da vezañ heñvel ouzh ar vogalennoù en nominativ (d.l.e. ar stumm-meneg), da skouer e hungareg: Aour, tungsten, zink, uraniom, h.a., a vez kavet e kondon Bouryatia. A-bouez-bras evit armerzh ar vro eo al labour-douar ivez pa vez gounezet gwinizh ha legumaj dreist-holl. A-hend-all e vez gounezet arc'hant dre chaseal ha pesketa."
  >>> for sent in s.segment(para):
  ...     print(sent)
  ...
  Peurliesañ avat e kemm ar vogalennoù e c'hengerioù evit dont da vezañ heñvel ouzh ar vogalennoù en nominativ (d.l.e. ar stumm-meneg), da skouer e hungareg: Aour, tungsten, zink, uraniom, h.a., a vez kavet e kondon Bouryatia.
  A-bouez-bras evit armerzh ar vro eo al labour-douar ivez pa vez gounezet gwinizh ha legumaj dreist-holl.
  A-hend-all e vez gounezet arc'hant dre chaseal ha pesketa.
  ```



  | Language             | Autonym       | Code | (CV) | (WP) | Phon | Valid | Alphabet | Segment |
  |--------------------- |-------------- |----- |------|----- |----------- |----------|---------- |------------|
  | Abkhaz                | Аԥсуа         |`abk` | `ab` |  —  | ✔          | ✔         | ✔        |           |
  | Amharic              | አማርኛ          | `amh` | —  | `am` | ✔           |      ✔      | ✔         |           |
  | Arabic               | اَلْعَرَبِيَّةُ       |`ara` | `ar` | `ar`  |     —       |   ✔         |          ✔  |            |
  | Assamese             |  অসমীয়া    |`asm` | `as`   |   `as` |   ✔      |       ✔   |    ✔     |            |
  | Asturian             | Asturianu | `ast` | `ast` | `ast` |         |  ✔         |  ✔       |          |
  | Azeri                | Azərbaycanca | `aze` | `az` | `az` |         |  ✔         |  ✔       |          |
  | Bashkort             | Башҡортса     |`bak` | `ba`  |  `ba` |     ✔      |   ✔       | ✔        |           |
  | Basaa                | Basaa         |`bas` | `bas`  |  — |     ✔      |      ✔      | ✔        |           |
  | Belarusian           | Беларуская мова |`bel` | `be`  |  `be` |     ✔      |   ✔         | ✔        |           |
  | Bengali              | বাংলা            |`ben` | `bn`  |  `bn` |          |   ✔       | ✔        |   ✔        |
  | Breton               | Brezhoneg     |`bre` | `br`   | `br` | ✔          | ✔         | ✔        |      ✔     |
  | Bulgarian            | Български | `bul` | `bg`   | `bg` | ✔          |    ✔      | ✔        |           |
  | Catalan              | Català        |`cat` | `ca`   | `ca` |            |    ✔        |      ✔    |            |
  | Czech                | Čeština       |`ces` | `cs`   |`cs` |    ✔        |    ✔        |  ✔        |            |
  | Chukchi              | Ԓыгъоравэтԓьэн |`ckt` | —   | — | ✔          | ✔         | ✔        |           |
  | Chuvash              | Чӑвашла       |`chv` | `cv`   |`cv`| ✔          | ✔         | ✔        |      ✔     |
  | Hakha Chin           | Hakha Lai     |`cnh` | `cnh`  |—  |            |      ✔      |     ✔      |            |
  | Highland Chatino     |  —            |`ctp` |  —   |  — |             |        ✔     |     ✔      |            |
  | Welsh                | Cymraeg       |`cym` | `cy`   |`cy`|       ✔      |        ✔     |     ✔      |            |
  | Dhivehi              | ދިވެހި           |`div` | `dv`   |`dv`| ✔          |    ✔     |   ✔    |      ✔    |
  | Greek                | Ελληνικά      |`ell` | `el`   |`el`| ✔          |      ✔   |  ✔      |         |
  | Danish               | Dansk         |`dan` | `da`   |`da`|            |     ✔    |     ✔      |            |
  | German               | Deutsch       |`deu` | `de`   |`de`|            |          ✔  |     ✔      |            |
  | English              | English       |`eng` | `en`   |`en`|      —      |    ✔        |    ✔       |            |
  | Esperanto            | Esperanto     |`epo` | `eo`   |`eo`|            |      ✔      |   ✔       |            |
  | Ewe                  | Eʋegbe        |`ewe` | `ee`   |`ee`|      ✔        |      ✔      |   ✔       |            |
  | Spanish              | Español             |`spa` | `es`   |`es`|       ✔      |    ✔        |       ✔   |            |
  | Erzya                | Эрзянь кель |`myv`    | `myv`   |`myv`|             |    ✔         |   ✔       |            |
  | Estonian             | Eesti               |`est`    | `et`   |`et`|     ✔        |    ✔         |   ✔       |            |
  | Basque               | Euskara             |`eus` | `eu`   |`eu`|     ✔      |      ✔        |    ✔      |     ✔        |
  | Persian              | فارسی               |`pes` | `fa`   |`fa`|    —        |       ✔    |    ✔      |            |
  | Finnish              | Suomi               |`fin` | `fi`   |`fi`| ✔           |   ✔        |   ✔       |            |
  | French               | Français            |`fra` | `fr`   |`fr`|     —       |        ✔     |     ✔     |            |
  | Frisian              | Frysk               |`fry` | `fy-NL`   |`fy`|            |     ✔       |       ✔    |     ✔        |
  | Igbo                 | Ásụ̀sụ́ Ìgbò          |`ibo` | `ig`   |`ig`|    ✔        |       ✔      |    ✔      |            |
  | Irish                | Gaeilge             |`gle` | `ga-IE`   |`ga`|            |    ✔       |    ✔      |            |
  | Galician             | Galego              |`glg` | `gl`   |`gl`|       ✔       |    ✔       |    ✔      |            |
  | Guaraní              | Avañeʼẽ             |`gug` | `gn`   |`gn`|       ✔       |    ✔      |    ✔      |            |
  | Hindi                | हिन्दी                                              |`hin` | `hi`   | `hi`           |       ✔    |      ✔    |       ✔     |
  | Hausa                | Harshen Hausa       |`hau` | `ha`  |`ha` |     ✔       |    ✔        |       ✔   |             |
  | Upper Sorbian        | Hornjoserbšćina     |`hsb` | `hsb`  |`hsb` |            |       ✔     |       ✔   |       ✔      |
  | Hungarian            | Magyar nyelv     |`hun` | `hu`  |`hu` |      ✔       |       ✔       |     ✔     |            |
  | Armenian             | Հայերեն         | `hye` | `hy-AM` |`hy`| ✔        |      ✔     |       ✔   |             |
  | Interlingua          | Interlingua     |`ina` | `ia`  |`ia` |    ✔         |    ✔        |     ✔     |            |
  | Indonesian           | Bahasa indonesia     |`ind` | `id` |`id`  |       ✔        |       ✔     |     ✔     |            |
  | Icelandic            | Íslenska |`isl` | `is` |`is`  |            |       ✔     |    ✔      |            |
  | Italian              | Italiano     |`ita` | `it` |`it`  |     ✔       |  ✔         |    ✔      |            |
  | Japanese             | 日本語     |`jpn` | `ja`   |`ja`|      —      |           |     —     |            |
  | Georgian             |  ქართული ენა    |`kat` | `ka`  |`ka` |    ✔          |      ✔      | ✔         |            |
  | Kabyle               | Taqbaylit     |`kab` | `kab`  |`kab` |      ✔        |     ✔       |      ✔      |            |
  | Kazakh               | Қазақша     |`kaz` | `kk`  |`kk` |   ✔          |     ✔        |      ✔     |            |
  | Kikuyu               | Gĩgĩkũyũ    | `kik` | `ki` | `ki` |  ✔          |     ✔        |      ✔     |            |
  | Kyrgyz               | Кыргызча     |`kir` | `ky`  |`ky` |    ✔         |     ✔        |  ✔        |    ✔          |
  | Kurmanji Kurdish     | Kurmancî    |`kmr` | `ku`  |`ku` |      ✔       |   ✔          |   ✔       |              |
  | Sorani Kurdish       | سۆرانی  |`ckb` | `ckb`  |`ckb` |      ✔       |   ✔          |   ✔       |              |
  | Komi-Zyrian          | Коми кыв     |`kpv` | `kv`  |`kv` |       ✔       |           |  ✔        |            |
  | Luganda              | Luganda     |`lug` | `lg`  |`lg` |       ✔       |        ✔     |       ✔       |            |
  | Lithuanian           | Lietuvių kalba     |`lit` | `lt` |`lt`  |   ✔         |      ✔      |  ✔          |            |
  | Lingala              | Lingála     |`lin` | `ln` |`ln`  |            |      ✔      |  ✔          |            |
  | Latvian              | Latviešu valoda    |`lvs` | `lv` |`lv`  |  ✔          |      ✔     |     ✔       |            |
  | Luo                  | Dholuo             |`luo` | `luo` | —  |  ✔          |      ✔     |     ✔       |            |
  | Macedonian           | Македонски |`mkd` | `mk`  |`mk` |           |   ✔    |    ✔   |             |
  | Malayalam            | മലയാളം  |`mal` | `ml`  |`ml` |           |    ✔      |    ✔   |            |
  | Marathi              | मराठी           |`mar` | `mr`  |`mr` |           |    ✔   |    ✔   |             |
  | Hill Mari            | Мары йӹлмӹ |`mrj` | `mrj`  |`mrj` |           |   ✔     |    ✔   |             |
  | Meadow Mari          | Олык марий |`mhr` | `mhr`  |`mhr` |           |   ✔     |    ✔   |             |
  | Mongolian            | Монгол хэл |`khk` | `mn`  |`mn` | ✔          |   ✔     |    ✔   |        ✔     |
  | Moksha               | Мокшень кяль |`mdf` | `mdf`  |`mdf` | ✔          |   ✔      |     ✔     |  |
  | Maltese              | Malti     |`mlt` | `mt`  |`mt` |      ✔       |      ✔     |      ✔      |         ✔   |
  | Yoloxóchitl Mixtec   |           | `xty` | — | —  |                  |   ✔     |      ✔      |                |
  | Dutch                | Nederlands     |`nld` | `nl` |`nl`  |   ✔         |     ✔      |    ✔      |            |
  | Chewa                | Chichewa       | `nya` | `ny` | `ny` |   ✔         |     ✔      |    ✔      |            |
  | Sierra Puebla Nahuatl | —  | `azz` |— | — |   ✔      |  ✔         |  ✔       |          |
  | Nepali               |  नेपाली|`ne` | `ne`  |`ne` |             |      ✔     |      ✔      |            |
  | Norwegian Nynorsk    | Nynorsk |`nno` | `nn-NO` |`nn`  |            |     ✔      |    ✔      |            |
  | Oriya                | ଓଡ଼ିଆ                                       |`ori` | `or`  |`or` |            |     ✔      |    ✔      |        ✔     |
  | Punjabi              | ਪੰਜਾਬੀ     |`pan` | `pa-IN`   | `pa`  |          |       ✔    |     ✔     |            |
  | Polish               | Polski     |`pol` | `pl`  |`pl` |   ✔          |       ✔     |     ✔     |            |
  | Portuguese           | Português     |`por` | `pt`  |`pt` |            |    ✔        |     ✔     |            |
  | Kʼicheʼ              | Kʼicheʼ             |`quc` | — | — |   ✔          |   ✔        |      ✔    |            |
  | Romansch (Sursilvan) | Romontsch     |`roh` | `rm-sursilv`  |`rm` |            |      ✔     |  ✔        |        ✔      |
  | Romansch (Vallader)  | Rumantsch     |`roh` | `rm-vallader`  |`rm` |            |     ✔      |   ✔       |        ✔      |
  | Romanian             | Românește     |`ron` | `ro`  |`ro` |   ✔          |    ✔         |    ✔       |            |
  | Russian              | Русский     |`rus` | `ru`   |`ru`|            |      ✔      |     ✔     |            |
  | Kinyarwanda          | Kinyarwanda     |`kin` | `rw` |`rw`  |    ✔         |     ✔       |    ✔       |            |
  | Sakha                | Саха тыла  |`sah` | `sah`   |`sah`| ✔          |      ✔  |  ✔     |      ✔    |
  | Sardinian            | Limba sarda |`srd` | `sc`   |`sc`|           |      ✔  |  ✔     |          |
  | Santali              | ᱥᱟᱱᱛᱟᱲᱤ |`sat` | `sat`   |`sat`| ✔          |      ✔  |  ✔     |          |
  | Saraiki              | |`skr` | `skr`   | — | ✔          |      ✔  |  ✔     |          |
  | Serbian              | Srpski  |`srp` | `sr`  |`sr` | ✔           |     ✔      |    ✔      |            |
  | Slovak               | Slovenčina |`slk` | `sk`  |`sk` | ✔           |   ✔         |    ✔      |            |
  | Slovenian            | Slovenščina     |`slv` | `sl`  |`sl` | ✔           |   ✔         |    ✔      |            |
  | Swahili              | Kiswahili    |`swa` | —  |`sw` |     ✔        |     ✔        |     ✔     |            |
  | Swedish              | Svenska      |`swe` | `sv-SE`  |`sv` |     ✔        |     ✔        |     ✔     |            |
  | Tamil                | தமிழ்    |`tam` | `ta`   |`ta`|       ✔      |     ✔      |        ✔   |            |
  | Thai                 | ภาษาไทย     |`tha` | `th`  |`th` |    ✔        |    ✔       |     ✔     |            |
  | Tigre                | ትግራይት |`tig` | `ti`  |`tig` |            |       ✔     |      ✔     |             |
  | Tigrinya             | ትግርኛ |`ti` | `ti`  |`ti` |            |       ✔     |      ✔     |             |
  | Turkish              | Türkçe |`tur` | `tr`  |`tr` |   ✔         |       ✔     |      ✔     |        ✔     |
  | Tatar                | Татар теле |`tat` | `tt`  |`tt` | ✔          |   ✔     |  ✔     |     ✔      |
  | Highland Totonac     | —          |`tos` | —  | — |           |   ✔     |  ✔     |           |
  | Twi                  | Twi        | `tw` | `tw`  | `tw` | ✔          |   ✔     |  ✔    |            |
  | Ukrainian            |  Українська мова    |`ukr` | `uk` |`uk`  |   ✔         |     ✔      |    ✔       |            |
  | Urdu                 | اُردُو |`urd` | `ur` |`ur`  |   ✔         |      ✔      |    ✔       |            |
  | Uyghur               | ئۇيغۇر تىلى |`uig` | `ug` |`ug`  |   ✔         |    ✔        |    ✔       |            |
  | Uzbek                | Oʻzbekcha |`uzb` | `uz` |`uz`  |   ✔         |   ✔        |    ✔       |            |
  | Vietnamese           | Tiếng Việt     |`vie` | `vi` |`vi`  |       ✔      |       ✔     |    ✔      |       ✔      |
  | Votic                | Vaďďa tšeeli    |`vot` | `vot` |  —  |            |      ✔      |   ✔       |            |
  | Wolof                | Wolof |`wol` | —  |  `wo`  |      ✔        |      ✔       |   ✔       |            |
  | Yoruba               | Èdè Yorùbá  |`yor` | —  |  `yo`  |      ✔        |      ✔       |   ✔       |            |
  | Chinese (China)      | 中文     |`cmn` | `zh-CN` |`zh`  |      —      |           |    —      |            |
  | Chinese (Hong Kong)  | 中文     |`cmn` | `zh-HK`  |`zh` |      —      |           |    —      |            |
  | Chinese (Taiwan)     | 中文     |`cmn` | `zh-TW`   |`zh`|      —      |           |    —      |            |






  There are potentially a lot of better language-specific systems for doing these tasks, but each one has
  a slightly different API, so if you want to support all the Common Voice languages or even a reasonable
  subset you have to learn and use the same number of language-specific APIs.

  The idea of these utilities is to provide adequate implementations of things are are likely to be useful
  when working with all the languages in Common Voice. If you are working on a single language or have
  a specific setup or are using more data than just Common Voice, maybe this isn't for you. But if you
  want to just train [coqui-ai/STT](https://github.com/coqui-ai/STT/) on Common Voice, then maybe it is :)



  Depending on the language in Common Voice, the transcripts can contain a lot of random punctuation,
  numerals, and incorrect character encodings (for example Latin *ç* instead of Cyrillic *ҫ* for Chuvash). These
  may look the same but will result in bigger sparsity for the model. Additionally some languages may
  have several encodings of the same character, such as the apostrophe. These will ideally be normalised
  before training.

  Also, if you are working with a single language you probably have time to look through all the transcripts
  for the alphabetic symbols, but if you want to work with a large number of Common Voice languages at the
  same time it's useful to have them all in one place.



  That's right, some of the languages are either not in Common Voice (yet!) or are in Common Voice but have
  not been released yet. If I've been working with them I've included them anyway.



  * [`epitran`](https://github.com/dmort27/epitran/): Great grapheme to phoneme system that supports a wide
    range of languages.



  All the code, aside from that explicitly licensed under a different licence, is licensed under
  the [AGPL v 3.0](https://www.gnu.org/licenses/agpl-3.0.en.html).



  * Grapheme to phoneme correspondences for the following languages from [`epitran`](https://github.com/dmort27/epitran/):
    * `vi`, `uk`, `kk`, `ky`, `ta`
  * Code for [transducer lookup](https://github.com/mhulden/foma/blob/master/foma/python/attapply.py) from Måns Huldén.
  * Code for [Wikipedia extraction](https://github.com/apertium/WikiExtractor) from Apertium.
  * Code for [Coqui export](https://github.com/coqui-ai/STT/blob/main/bin/import_cv2.py) from [Coqui](https://coqui.ai).
  * Code for [NeMo export](https://github.com/NVIDIA/NeMo/blob/0e57b58a849f6275629910cdeebd608e528327bf/scripts/dataset_processing/get_commonvoice_data.py) from [NVIDIA](http://www.nvidia.com)


pkgId: 1530ff62d00c34a30b3cc2674fc0afced1b1170e1835e91bfaf6652aeda59d82
name: python-communex
arch: src
version: 0.1.34.6
epoch: 0
release: 1
summary: A library for Commune network focused on simplicity
url: https://pypi.org/project/communex/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-communex-0.1.34.6-1.src.rpm
checksum_type: sha256
description:
  [open an issue on GitHub]: https://github.com/agicommies/communex/issues/new/choose
  [CommuneX Discord channel]: https://go.agicommies.org/communex-channel
  [GitHub discussions page]: https://github.com/agicommies/communex/discussions
  [ruff-installation]: https://docs.astral.sh/ruff/installation/


pkgId: 10ac99dd66a4b8804bd9509629f0529f3293c8ebdc9a7a62be66e011ea2d2cbf
name: python-community
arch: src
version: 1.0.0b1
epoch: 0
release: 1
summary: merge together wellness checks to unify your shit
url: https://github.com/ewdurbin/community
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-community-1.0.0b1-1.src.rpm
checksum_type: sha256
description:
  merge together [wellness](https://github.com/warmwaffles/wellness) compatible
  checks to build a unified view of your conglomerated services


pkgId: 05865d4b8cfdc1f1ae20a0e04ad8f859a0997ac26c7a082a03167ac9fefc869d
name: python-communityid
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Community ID flow hashing
url: https://github.com/corelight/pycommunityid
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-communityid-1.5.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a Python implementation of the open
  [Community ID](https://github.com/corelight/community-id-spec)
  flow hashing standard.
  It supports Python versions 2.7+ (for not much longer) and 3+.
  ![example foobar](https://github.com/corelight/pycommunityid/actions/workflows/python.yaml/badge.svg)


pkgId: 145b2d55afa1812a04fa46db68077c815b681bfbfab7f8b6548f7bb98f6591d9
name: python-compact-json
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: A JSON formatter that produces compact but human-readable
url: https://github.com/masaccio/compact-json
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compact-json-1.8.1-1.src.rpm
checksum_type: sha256
description:
  [![build:](https://github.com/masaccio/compact-json/actions/workflows/run-all-tests.yml/badge.svg)](https://github.com/masaccio/compact-json/actions/workflows/run-all-tests.yml)
  [![build:](https://github.com/masaccio/compact-json/actions/workflows/codeql.yml/badge.svg)](https://github.com/masaccio/compact-json/actions/workflows/codeql.yml)
  [![codecov](https://codecov.io/gh/masaccio/compact-json/branch/main/graph/badge.svg?token=EKIUFGT05E)](https://codecov.io/gh/masaccio/compact-json)

  `compact-json` is a JSON formatter that produces configurably compact JSON that remains human-readable.

  Any given container is formatted in one of three ways:

  * Python lists or dicts will be written on a single line, if their contents aren't too complex and the resulting line wouldn't be too long.
  * lists can be written on multiple lines, with multiple items per line, as long as those items aren't too complex.
  * Otherwise, each dict property or array item is written beginning on its own line, indented one step deeper than its parent.

  The following JSON is the standard output from running `python3 -mjson.tool`:

  ``` JSON
  {
      "widget": {
          "debug": "on",
          "window": {
              "title": "Sample Konfabulator Widget",
              "name": "main_window",
              "width": 500,
              "height": 500
          },
          "image": {
              "src": "Images/Sun.png",
              "name": "sun1",
              "hOffset": 250,
              "vOffset": 250,
              "alignment": "center"
          },
          "text": {
              "data": "Click Here",
              "size": 36,
              "style": "bold",
              "name": "text1",
              "hOffset": 250,
              "vOffset": 100,
              "alignment": "center",
              "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
          }
      }
  }
  ```

  The `window` and `image` objects are fairly short so when formatted with `compact-json` they can be formated on a single line. With the default setting the `text` object is still too long to fit on one line, but this can be configured to be longer:

  ``` JSON
  {
      "widget": {
          "debug": "on",
          "window": {"title": "Sample Konfabulator Widget", "name": "main_window", "width": 500, "height": 500},
          "image": {"src": "Images/Sun.png", "name": "sun1", "hOffset": 250, "vOffset": 250, "alignment": "center"},
          "text": {
              "data": "Click Here",
              "size": 36,
              "style": "bold",
              "name": "text1",
              "hOffset": 250,
              "vOffset": 100,
              "alignment": "center",
              "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
          }
      }
  }
  ```



  ``` shell
  python3 -m pip install compact-json
  ```



  As a python package, `compact-json` is instantiated with a `Formatter` class that has a range of properties to configure the formatting:

  ``` python
  import json
  from compact_json import Formatter, EolStyle

  formatter = Formatter()
  formatter.indent_spaces = 2
  formatter.max_inline_complexity = 10
  formatter.json_eol_style = EolStyle.LF


  with open("input.json", "r") as f:
      obj = json.load(f)
      json_string = formatter.serialize(obj)
      print(json_string)


  with open("input.json", "r") as f:
      obj = json.load(f)

  formatter.dump(obj, output_file="output.json", newline_at_eof=True)
  ```



  Unlike the builtin `json` package, `compact-json` will issue runtime warnings when dictionary keys are forced to strings or overwritten to ensure that the resulting JSON is well-formed:

  ``` python
  >>> from compact_json import Formatter
  >>> Formatter().serialize({100: "error", 200: "had", 300: ["a", "little", "lamb"], "100": "mary"})
  /path/src/compact_json/formatter.py:346: RuntimeWarning: coercing key value 100 to string
    warnings.warn(f"converting key value {k} to string", RuntimeWarning)
  /path/src/compact_json/formatter.py:346: RuntimeWarning: coercing key value 200 to string
    warnings.warn(f"converting key value {k} to string", RuntimeWarning)
  /path/src/compact_json/formatter.py:346: RuntimeWarning: coercing key value 300 to string
    warnings.warn(f"converting key value {k} to string", RuntimeWarning)
  /path/src/compact_json/formatter.py:349: RuntimeWarning: duplicate key value 100
    warnings.warn(f"duplicate key value {k}", RuntimeWarning)
  '{ "100": "mary", "200": "had", "300": ["a", "little", "lamb"] }'
  ```



  When installed from `pip` a command-line utility `compact-json` is installed which has some useful defaults and most of the parameters available in `Formatter` can be set on the command-line:

  ``` shell
  usage:     compact-json [-h] [-V]
                          [--output-filename [OUTPUT_FILENAME ...]]
                          [--crlf] [--max-inline-length N]
                          [--max-inline-complexity N]
                          [--max-compact-list-complexity N]
                          [--bracket-padding {simple,nested}] [--indent N]
                          [--tab-indent] [--justify-numbers]
                          [--prefix-string STRING] [--align-properties]
                          [json ...]

  Format JSON into compact, human readable form

  positional arguments:
    json                  JSON file(s) to parse (or stdin with "-")

  optional arguments:
    -h, --help            show this help message and exit
    -V, --version
    --output-filename [OUTPUT_FILENAME ...], -out [OUTPUT_FILENAME ...]
                          The output file name(s). If empty, no new JSON file(s)
                          will be saved. If provided, the number of output file
                          names must match that of the input files.
    --crlf                Use Windows-style CRLF line endings
    --max-inline-length N
                          Limit inline elements to N chars, excluding
                          indentation and leading property names (default=50)
    --max-inline-complexity N
                          Maximum nesting: 0=basic types, 1=dict/list, 2=all
                          (default=2)
    --max-compact-list-complexity N
                          Maximum nesting over multiple lines (default 1)
    --bracket-padding {simple,nested}
                          If nested padding, add speces inside outside brackes
                          for nested lists/dicts
    --indent N            Indent N spaces (default=4)
    --tab-indent          Use tabs to indent
    --justify-numbers     Right-align numbers with matching precision
    --prefix-string STRING
                          String attached to the beginning of every line
    --align-properties    Align property names of expanded dicts
    --unicode             Treat strings as unicode East Asian characters
  ```

  `compact-json` can be used in a shell pipeline to read from stdin when passed `-` as the file argument.



  The `Formatter` class has the following properties:



  Dictates what sort of line endings to use. `EolStyle.LF` is Unix-style line endings (the default) and `EolStyle.CRLF` Windows-style.



  Maximum length of a complex element on a single line. This includes only the data for the inlined element not indentation or leading property names. The default is 80.



  Maximum nesting level that can be displayed on a single line. A primitive type or an empty list or dict has a complexity of 0. A dict or list has a complexity of 1 greater than its most complex child. The default is 2.



  Maximum nesting level that can be arranged spanning multiple lines, with multiple items per line. The default is 1.



  If an inlined list or dict contains other lists or dicts, setting `nested_bracket_padding` to `True` will include spaces inside the outer brackets. The default is `True`.

  See also `simple_bracket_padding`.



  If an inlined list or dict does NOT contain other lists/dicts, setting `simple_bracket_padding` to `True` will include spaces inside the brackets. The default is `False`.

  See also `nested_bracket_padding`.



  If `True` (the default), includes a space after property colons.



  If `True` (the default), includes a space after commas separating list items and dict properties.



  Depth at which lists/dicts are always fully expanded, regardless of other settings

  * -1 = none. This is the default
  * 0 = root node only
  * 1 = root node and its children.



  Number of spaces to use per indent level (unless `use_tab_to_indent` is `True`). The default is 4.



  Uses a single tab per indent level, instead of spaces. The default is `False`.



  Value from 0 to 100 indicating how similar collections of inline dicts need to be to be formatted as a table. A group of dicts that don't have any property names in common has a similarity of zero. A group of dicts that all contain the exact same property names has a similarity of 100. Setting this to a value > 100 disables table formatting with dicts as rows. The default is 75.



  Value from 0 to 100 indicating how similar collections of inline lists need to be to be formatted as a table. Similarity for lists refers to how similar they are in length; if they all have the same length their similarity is 100. Setting this to a value > disables table formatting with lists as rows. The default is 75.



  If `True`, property names of expanded dicts are padded to the same size. The default is `False`.



  If `True`, numbers won't be right-aligned with matching precision. The default is `False`.



  String attached to the beginning of every line, before regular indentation.



  If `True` (the default), the output is guaranteed to have all incoming non-ASCII characters escaped. If `ensure_ascii` is `False`, these characters will be output as-is.



  If `True`, format strings using unicodedata.east_asian_width rather than simple string lengths



  `compact-json` is primarily a Python port of [FracturedJsonJs](https://github.com/j-brooke/FracturedJsonJs) by [j-brooke](https://github.com/j-brooke). FractureJson is also
  an excellent [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=j-brooke.fracturedjsonvsc). This package has no other relationship
  with this original code, and hence all the bugs are my own.



  All code in this repository is licensed under the [MIT License](https://github.com/masaccio/compact-json/blob/master/LICENSE.rst)



  Contributions are greatly appreciated and welcomed. Please follow the [project guidance](CONTRIBUTING.md) on how to contribute.


pkgId: 24df6d0ab7e0e56cbbedf86c746dcb13811f0dda6a6d107cb7493b3732d9a78a
name: python-compactify
arch: src
version: 2
epoch: 0
release: 1
summary: Make Python code more compact
url: https://pypi.org/project/compactify/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compactify-2-1.src.rpm
checksum_type: sha256
description:
  Compactify collapses sequential lines with only ()[]{}, and whitespace into one.



  ```bash
  pip install compactify
  compactify /path/to/filename.py
  cat /path/to/filename.py | compactify --from-stdin
  ```



  Compactify is tested with Python>=3.8.

rpm_license:
  MIT License  Copyright (c) 2023 OlleLindgren  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: 245167e958203bc99c89528d9251bba10b8a9f27344548fa22660fb12ba995c0
name: python-compare
arch: src
version: 0.2b
epoch: 0
release: 1
url: https://github.com/rudylattae/compare
rpm_license: Simplified BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compare-0.2b-1.src.rpm
checksum_type: sha256
summary:
  Alternative syntax for comparing/asserting expressions in Python. Supports pluggable matchers for custom comparisons.

description:
  Compare is a compact utility that provides an alternative, expressive
  syntax for comparing data values. Have you been looking for an escape
  from the stale XUnit style asserts that plague the omni-present unittest_?
  You may have found just what you need. I invite you to take a look at this
  little utility. If it fits your style, you may use it as a drop-in
  replacement for the "self.assert..." style of doing assertions in python.
  The compare API exposes the **expect** construct which allows
  you to compare values with readable and extensible syntax. It was designed
  to be a stand-alone alternative assertion syntax. As such you may use it
  as-is with your favorite testing/specification framework.
  **Documentation**: http://packages.python.org/compare
  **Project source**: https://github.com/rudylattae/compare
  **PyPI page**: http://pypi.python.org/pypi/compare


pkgId: d73bbe4af652aeb9993ed94d2bdfaabe0c4c80932c696def1714de43bd3be977
name: python-compare-locales
arch: src
version: 9.0.4
epoch: 0
release: 1
summary: Lint Mozilla localizations
url: https://pypi.org/project/compare-locales/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compare-locales-9.0.4-1.src.rpm
checksum_type: sha256
description:
  ![Build tests](https://github.com/mozilla/compare-locales/workflows/test/badge.svg)

  Lint Mozilla localizations

  Finds
  * missing strings
  * obsolete strings
  * errors on runtime errors without false positives
  * warns on possible runtime errors

  It also includes `l10n-merge` functionality, which pads localizations with
  missing English strings, and replaces entities with errors with English.

  If you want to check your original code for errors like duplicated messages,
  use `moz-l10n-lint`, which is also part of this package. You can also use
  this to check for conflicts between your strings and those already exposed
  to l10n.



  You configure `compare-locales` (and `moz-l10n-lint`) through a
  [project configuration](https://moz-l10n-config.readthedocs.io/en/latest/fileformat.html)
  file, `l10n.toml`.



  To check all locales in a project use

  ```bash
  compare-locales l10n.toml .
  ```

  To check Firefox against a local check-out of l10n-central, use

  ```bash
  compare-locales browser/locales/l10n.toml ../l10n-central
  ```

  If you just want to check particular locales, specify them as additional
  commandline parameters.

  To lint your local work, use

  ```bash
  moz-l10n-lint l10n.toml
  ```

  To check for conflicts against already existing strings:

  ```bash
  moz-l10n-lint --reference-project ../android-l10n/mozilla-mobile/fenix l10n.toml
  moz-l10n-lint --l10n-reference ../gecko-strings browser/locales/l10n.toml
  ```

  to check for a monolithic project like Fenix or a gecko project like Firefox,
  resp.


pkgId: 0ab6f04b9631ac707102afa51832068d7862754281c2ab2b26d9fc7ab53ef478
name: python-compare_datasets
arch: src
version: 0.1.21
epoch: 0
release: 1
summary: The library that compares two dataframes
url: https://pypi.org/project/compare_datasets/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compare_datasets-0.1.21-1.src.rpm
checksum_type: sha256
description:
  This powerful Python library is designed to facilitate easy and efficient comparison of data frames.



  - Universal Compatibility: The library is designed to work out of the box with data frames of any type, including pandas, polars, or Spark data frames. This flexibility allows you to use the library with your preferred data manipulation framework.

  - String Comparison: For string comparison, the library employs the Levenshtein distance algorithm. The Levenshtein distance is a string metric for measuring the difference between two sequences. The algorithm is used to identify the minimum number of single-character edits (insertions, deletions, or substitutions) required to change one word into the other.

  - Numeric Comparison: Numeric comparisons are conducted using the Euclidean distance between columns. This method is effective for identifying differences in numeric data, providing insights into variations between datasets.

  - User-friendly reporting: The library generates a detailed tabular report that provides a comprehensive overview of the differences between the two datasets.


  ```python
  import polars as pl
  expected = pl.DataFrame(
      {
      'id': [101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
      'another_id':[1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010],
      'name': ['John', 'Alice', 'Bob', 'Eva', 'Charlie', 'Linda', 'David', 'Sophie', 'Michael', 'Emma'],
      'age': list(range(25, 35)),
      'height': [170, 165, 180, 160, 175, 160, 185, 175, 172, 168],
      'weight': [70, 55, 80, 50, 68, 52, 95, 73, 78, 60]
      }
  )

  tested = pl.DataFrame(
      {
      'id': [102, 103, 104, 105, 106, 107, 108, 109, 110],
      'another_id':[1002, 1003, 1004, 1005, 1006, 1007, 2008, 2009, 2010],
      'name': ['Albert', 'Bobby', 'Evan', 'Charlie', 'Linda', 'David', 'Sophie', 'Michael', 'Emma'],
      'age': list(range(25, 34)),
      'height': [165, 180, 160, 175, 160, 185, 175, 172, 168],
      'weight': [55, 80, 50, 68, 52, 95, 73, 78, 60]

      }
  )
  from compare_datasets import Compare
  key = ['id', 'another_id']
  compared = Compare(tested=tested,expected=expected, key=key) # creates a Compare object
  print(compared) # prints the tabulated result
  compared.get_report("<PATH_TO_SAVE_REPORT>, format='txt'") # saves the report to a file
  ```

  Thisi s particularly useful (not exhaustive) in the following scenarios:

  - Testing: Quickly identify and verify differences between expected and actual data frames during testing phases.

  - Analysis: Gain insights into the variations and discrepancies between two datasets, facilitating thorough data analysis.


  - Add other distance functions
  - Add seamless integration with pytest
  - Write a user guide


  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: f7fdc271b9c83a27bba912b12e9c3bc47b9ea7b9b383ffd17596f969bfa38743
name: python-compas
arch: src
version: 2.4.2
epoch: 0
release: 1
summary: The main COMPAS framework library.
url: https://compas-dev.github.io/compas
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-2.4.2-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/compas-dev/compas/workflows/build/badge.svg)
  [![codecov](https://codecov.io/github/compas-dev/compas/graph/badge.svg?token=wpkfew9szQ)](https://codecov.io/github/compas-dev/compas)
  [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas.svg)](https://github.com/compas-dev/compas)
  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![pip downloads](https://img.shields.io/pypi/dm/compas)](https://pypi.python.org/project/COMPAS)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
  [![Conda (channel only)](https://img.shields.io/conda/vn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![DOI](https://zenodo.org/badge/104857648.svg)](https://zenodo.org/badge/latestdoi/104857648)
  [![Twitter Follow](https://img.shields.io/twitter/follow/compas_dev?style=social)](https://twitter.com/compas_dev)

  The **COMPAS** framework is an open-source, Python-based framework for computational research and collaboration in architecture, engineering, digital fabrication and construction.

  The framework consists of a general-purpose core library, written in pure Python, and a growing collection of extensions that provide easy access to peer-reviewed research, state-of-the-art external libraries such as CGAL, libigl and Triangle, and tools with specialized functionality for AEFC applications such as Abaqus, ANSYS, SOFISTIK, ROS, etc.

  COMPAS has dedicated packages for working with Rhino, Grasshopper, and Blender, but it can be used in any environment that supports Python scripting. It is available on PyPI and conda-forge and can be easily installed using popular package managers on multiple platforms.



  We are working on a new major release of the framework, COMPAS 2.0!
  Therefore, be aware that the current version of the repository already contains some changes that are incompatible with the version 1 releases.
  The documentation of the latest stable version (COMPAS 1.17.9) [is available here](https://compas.dev/compas/1.17.9).



  The recommended way to install **COMPAS** is to use [Anaconda/conda](https://conda.io/docs/):

  ```bash
  conda config --add channels conda-forge
  conda install compas
  ```

  For other installation options, [see the user guide](https://compas.dev/compas/latest/userguide/installation.html)



  * [First steps](https://compas.dev/compas/latest/userguide/firststeps.html)
  * [Tutorials: geometry basics](https://compas.dev/compas/latest/userguide/basics.geometry.html)
  * [Tutorials: datastructures](https://compas.dev/compas/latest/userguide/basics.datastructures.html)
  * [API Reference](https://compas.dev/compas/latest/api/index.html)



  The **COMPAS** framework has a [forum for questions and discussions](https://forum.compas-framework.org/).



  If you find a bug, please help us solve it by [filing a report](https://github.com/compas-dev/compas/issues).



  If you want to contribute, check out the [contribution guidelines](https://compas.dev/compas/latest/devguide/index.html).



  See changes between releases on the [changelog](https://github.com/compas-dev/compas/blob/main/CHANGELOG.md).



  The main library of **COMPAS** is [released under the MIT license](https://compas.dev/compas/latest/userguide/license.html).



  COMPAS is developed by a small team of core developers (`compas-dev`) and with the support of contributers from the open source community.
  See the [list of authors](https://github.com/compas-dev/compas/blob/main/AUTHORS.md) for a complete overview...

rpm_license:
  MIT License  Copyright (c) 2017-2023 COMPAS Association  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: ea80ddff07c940c779f6d2d1f16c14b82dda018fb49b6ac18d68b56794c06e2e
name: python-compas-ags
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: COMPAS package for Computational Graphic Statics
url: https://compas-dev.github.io/compas_ags
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-ags-1.3.1-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/blockresearchgroup/compas_ags/workflows/build/badge.svg)

  [![GitHub - License](https://img.shields.io/github/license/blockresearchgroup/compas_ags.svg)](https://github.com/blockresearchgroup/compas_ags)

  **compas_ags** is a COMPAS package for Computational Graphic Statics.
  It combines implementations of the following papers:

  * Algebraic Graph Statics
  * Bi-directional Algebraic Graph Statics
  * Load-path optimisation of funcicular networks

  See "[Publications](https://blockresearchgroup.github.io/compas_ags/latest/publications.html)" for more info.



  Have a look at the "Getting Started" instructions in the docs: <https://blockresearchgroup.github.io/compas_ags/latest/gettingstarted.html>.



  A good place to start exploring AGS through `compas_ags` are the [examples](https://blockresearchgroup.github.io/compas_ags/latest/examples.html).



  For questions and feedback, read through or post something in the [compas_ags category](https://forum.compas-framework.org/c/compas-ags) of the COMPAS forum.



  If you find a bug, please help us solve it by [filing a report](https://github.com/blockresearchgroup/compas_ags/issues).



  If you want to contribute, check out our [developer guidelines](https://blockresearchgroup.github.io/compas_ags/latest/devguide.html).



  `compas_ags` is licensed under the MIT License. See [LICENSE](https://github.com/blockresearchgroup/compas_ags/blob/master/LICENSE), for more information.

rpm_license:
  MIT License  Copyright (c) 2017 Block Research Group, ETH Zurich  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: 7ef93bf06062228637ac0a77c8136474fd880a1b8e17da00f7bad89897e7554c
name: python-compas-cadwork
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: COMPAS package for integrating with cadwork.
url: https://gramaziokohler.github.io/compas_cadwork/latest/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-cadwork-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/gramaziokohler/compas_cadwork/actions/workflows/build.yml/badge.svg)](https://github.com/gramaziokohler/compas_cadwork/actions/workflows/build.yml)
  [![License](https://img.shields.io/github/license/gramaziokohler/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![pip downloads](https://img.shields.io/pypi/dm/compas_cadwork)](https://pypi.python.org/project/compas_cadwork)
  [![PyPI Package latest release](https://img.shields.io/pypi/v/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![Supported implementations](https://img.shields.io/pypi/implementation/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![Twitter Follow](https://img.shields.io/twitter/follow/compas_dev?style=social)](https://twitter.com/compas_dev)

  ![COMPAS Cadwork](https://raw.githubusercontent.com/gramaziokohler/compas_cadwork/refs/heads/main/compas_cadwork.JPG)

  COMPAS cadwork is an open-source Python package which allows you to harness the power of the COMPAS framework inside cadwork 3d.
  Make use of COMPAS' extensive geometry kernel, data structures, and algorithms to create, manipulate, and analyze your 3d models in cadwork.
  Gain access to the COMPAS ecosystem which includes a wide range of tools and libraries engineered for the AEC industry.



  > For the different installation options please see the [installation guide](https://gramaziokohler.github.io/compas_cadwork/latest/installation.html).

  To install `compas_cadwork` directly to cadwork 3d, run:

  ```bash
  pip install compas_cadwork --target "C:\Program Files\cadwork.dir\EXE_30\Pclib.x64\python310\site-packages" --upgrade
  ```



  * [Documentation](https://gramaziokohler.github.io/compas_cadwork/)
  * [COMPAS CADWORK API Reference](https://gramaziokohler.github.io/compas_cadwork/latest/api.html)



  We encourage the use of the [COMPAS framework forum](https://forum.compas-framework.org/)
  for questions and discussions.



  If you found an issue or have a suggestion for a dandy new feature, please file a new issue in our [issue tracker](https://github.com/gramaziokohler/compas_cadwork/issues).



  We love contributions!

  Check the [Contributor's Guide](https://compas.dev/compas/latest/devguide/)
  for more details.



  `compas_cadwork` is currently developed by [Gramazio Kohler Research](https://gramaziokohler.arch.ethz.ch/).

rpm_license:
  MIT License    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: bdbb888547a072fdc0f8dd8ddebe5d71f33833695013d3106aa0e393c48f6645
name: python-compas-cadwork
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: COMPAS package for integrating with cadwork.
url: https://gramaziokohler.github.io/compas_cadwork/latest/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-cadwork-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/gramaziokohler/compas_cadwork/actions/workflows/build.yml/badge.svg)](https://github.com/gramaziokohler/compas_cadwork/actions/workflows/build.yml)
  [![License](https://img.shields.io/github/license/gramaziokohler/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![pip downloads](https://img.shields.io/pypi/dm/compas_cadwork)](https://pypi.python.org/project/compas_cadwork)
  [![PyPI Package latest release](https://img.shields.io/pypi/v/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![Supported implementations](https://img.shields.io/pypi/implementation/compas_cadwork.svg)](https://pypi.python.org/pypi/compas_cadwork)
  [![Twitter Follow](https://img.shields.io/twitter/follow/compas_dev?style=social)](https://twitter.com/compas_dev)

  ![COMPAS Cadwork](https://raw.githubusercontent.com/gramaziokohler/compas_cadwork/refs/heads/main/compas_cadwork.jpg)

  COMPAS cadwork is an open-source Python package which allows you to harness the power of the COMPAS framework inside cadwork 3d.
  Make use of COMPAS' extensive geometry kernel, data structures, and algorithms to create, manipulate, and analyze your 3d models in cadwork.
  Gain access to the COMPAS ecosystem which includes a wide range of tools and libraries engineered for the AEC industry.



  > For the different installation options please see the [installation guide](https://gramaziokohler.github.io/compas_cadwork/latest/installation.html).

  To install `compas_cadwork` directly to cadwork 3d, run:

  ```bash
  pip install compas_cadwork --target "C:\Program Files\cadwork.dir\EXE_30\Pclib.x64\python310\site-packages" --upgrade
  ```



  * [Documentation](https://gramaziokohler.github.io/compas_cadwork/)
  * [COMPAS CADWORK API Reference](https://gramaziokohler.github.io/compas_cadwork/latest/api.html)



  We encourage the use of the [COMPAS framework forum](https://forum.compas-framework.org/)
  for questions and discussions.



  If you found an issue or have a suggestion for a dandy new feature, please file a new issue in our [issue tracker](https://github.com/gramaziokohler/compas_cadwork/issues).



  We love contributions!

  Check the [Contributor's Guide](https://compas.dev/compas/latest/devguide/)
  for more details.



  `compas_cadwork` is currently developed by [Gramazio Kohler Research](https://gramaziokohler.arch.ethz.ch/).

rpm_license:
  MIT License  Copyright (c) 2024 Gramazio Kohler Research, ETH Zurich  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: 1b0f7293bc4cbf588fd2bf0b819e71b71430ec0a4ca08aed6a3cb55752d35e27
name: python-compas-cem
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: The Combinatorial Equilibrium Modeling framework for COMPAS
url: https://github.com/arpastrana/compas_cem
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-cem-0.8.0-1.src.rpm
checksum_type: sha256
description:
  * **Mix tension and compression forces:** Explore a wider spectrum of structural typologies by combining internal tension and compression forces in the same structure. Design space frames, bridges, tensegrities, and staircases and go beyond the conventional catalog of compression-only shells and cable-nets!
  * **Solve constrained form-finding problems efficiently via automatic differentiation:** Generate forms in static equilibrium that simultaneously meet a priori design constraints such as best-fitting a global target shape, restraining bar lengths, and controlling the reaction forces at the supports of a structure.
  * **Usable across different 3D modeling software and operating systems:** COMPAS CEM runs on Windows, MacOS and Linux (perhaps one day in the `metaverse`_) and it does not depend on any CAD software to work. However, it provides the necessary interfaces to be seamlessly used inside popular design environments like `Rhino`_, `Blender`_, and `Grasshopper`_. As a `COMPAS`_ extension, COMPAS CEM offers native integration and data exchange with other extensions and plugins in the COMPAS ecosystem.
  * **Move those sliders with the Grasshopper plugin:** Are you a `Grasshopper`_ person? Worry not. COMPAS CEM is also shipped as a precooked Grasshopper plugin to readily integrate our constrained form-finding engine into your next spaghetti pipeline 🍝.


pkgId: 3035b9db61e95461a849dbeb6a024881ac3c09173a8951c19ce8f57aa2f72e4b
name: python-compas-invocations
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A collection of reusable pyinvoke tasks
url: https://github.com/compas-dev/compas_invocations
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-invocations-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/compas_invocations.svg)](https://pypi.org/project/compas-invocations/)

  A collection of reusable pyinvoke tasks



  Import and add tasks to a collection in your project's `tasks.py` file:

      import os
      from invoke import Collection
      from compas_invocations import style

      ns = Collection(style.check, style.lint)
      ns.configure(
          {
              "base_folder": os.path.dirname(__file__),
          }
      )

  For a more complete example, check the [`tasks.py`](tasks.py) of this project.


pkgId: 36d744070f5826e40ed68eeb2784bf4e15692818ff1d6319585891d52bc02021
name: python-compas-invocations2
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A collection of reusable pyinvoke tasks.
url: https://compas-dev.github.io/compas_invocations2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-invocations2-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/compas_invocations2.svg)](https://pypi.org/project/compas-invocations/)

  A collection of reusable pyinvoke tasks



  Import and add tasks to a collection in your project's `tasks.py` file:

      import os
      from invoke import Collection
      from compas_invocations2 import style

      ns = Collection(style.check, style.lint)
      ns.configure(
          {
              "base_folder": os.path.dirname(__file__),
          }
      )

  For a more complete example, check the [`tasks.py`](tasks.py) of this project.

rpm_license:
  MIT License  ETH Zurich  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: abda6ca47a597105f53670cd1e28174ad9d4e1226e29e51f92fcb214e276a76f
name: python-compas-notebook
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: A COMPAS viewer for Jupyter notebooks based on PyThreeJS.
url: https://compas-dev.github.io/compas_notebook
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-notebook-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas_notebook.svg)](https://github.com/compas-dev/compas_notebook)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compas-notebook.svg)](https://pypi.python.org/project/compas-notebook)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/compas-notebook.svg)](https://pypi.python.org/project/compas-notebook)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/compas-dev/compas_notebook/main?urlpath/lab/tree/notebooks)

  Notebook visualization backend for COMPAS using pythreejs.



  To get started with `compas_notebook` have a look at [the documentation](https://compas.dev/compas_notebook).



  For questions and feedback, have a look at the [COMPAS Forum](https://forum.compas-framework.org).



  If you run into problems, please file an issue on the [issue tracker](https://github.com/compas-dev/compas_notebook/issues). If we don't know it is broken, we can't fix it...



  Guidelines for developers are under construction. However, we always accept contributions in the form of Pull Requests.



  `compas_notebook` is licensed under the MIT License. See [LICENSE](https://github.com/compas-dev/compas_notebook/blob/master/LICENSE), for more information.

rpm_license:
  MIT License  ETH Zurich - Block Research Group  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: cef3c066c9b6a12213f2b182d2b6bb117bfda08a10b5ca75b283d966be0c2b4a
name: python-compas-occ
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: COMPAS wrapper for the Python bindings of OCC.
url: https://compas-dev.github.io/compas_occ
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-occ-1.2.1-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/compas-dev/compas_occ/workflows/build/badge.svg)
  [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas_occ.svg)](https://github.com/compas-dev/compas_occ)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compas_occ.svg)](https://pypi.python.org/project/compas_occ)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/compas_occ.svg)](https://pypi.python.org/project/compas_occ)
  [![Conda - Latest Release](https://anaconda.org/conda-forge/compas_occ/badges/version.svg)](https://anaconda.org/conda-forge/compas_occ)
  [![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/compas_occ)](https://anaconda.org/conda-forge/compas_occ)

  COMPAS wrapper for the Python bindings (`pythonocc-core`) of the 3D geometry kernel of Open Cascade.

  More info coming soon.
  In the meantime, see the docs at <https://compas.dev/compas_occ/latest/index.html>.

rpm_license:
  MIT License  Copyright (c) ETH Zurich - Block Research Group  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: 5115dc977c00542200c9202fb3e4715c507d24fba15343e5d2cdeb28059b3f94
name: python-compas-rcf
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: python module for MAS DFAB project Rapid Clay Formations
url: https://github.com/tetov/compas_rcf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-rcf-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Travis (.com)](https://img.shields.io/travis/com/tetov/compas_rcf?style=for-the-badge)](https://travis-ci.com/tetov/compas_rcf)
  [![GitHub](https://img.shields.io/github/license/tetov/compas_rcf?style=for-the-badge)](https://github.com/tetov/compas_rcf/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/compas_rcf?style=for-the-badge)](https://pypi.org/project/compas-rcf/)

  python module for MAS DFAB project Rapid Clay Formations

  * [Getting started](https://compas_rcf.tetov.se/getting_started.html) - for installation and update instructions
  * [Example files](https://compas_rcf.tetov.se/examples.html) - for demonstration purposes
  * [Contributing](https://compas_rcf.tetov.se/contributing.html) - how to start working on the code
  * [Known issues](https://compas_rcf.tetov.se/known_issues.html) - for things that we know don't work
  * [Issues](https://github.com/tetov/compas_rcf/issues) - for unknown issues, as well as suggestions and questions
  * [Documentation](https://compas_rcf.tetov.se/)



  `compas_rcf` is part is built on top of [`compas`](https://compas-dev.github.io/),
   [`compas_fab`](https://gramaziokohler.github.io/compas_fab/) and
   [`compas_rrc`](https://bitbucket.org/ethrfl/compas_rrc/).



  Installation of the package requires Python \>\= 3.6.

  Big parts are compatible with IronPython 2.7 (to be run inside Rhino plugin
  Grasshopper).

  The modules that require Python \>\= 3.6 should raise an exception on import.


pkgId: 20ec0daf96d765ce60d33807558829b8a12d8878f7834430915299114c2435f1
name: python-compas-view2
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Second generation viewers for the COMPAS framework
url: https://github.com/compas-dev/compas_view2
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-view2-0.11.0-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/compas-dev/compas_view2/workflows/build/badge.svg)
  [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas_view2.svg)](https://github.com/compas-dev/compas_view2)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compas_view2.svg)](https://pypi.python.org/project/compas_view2)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/compas_view2.svg)](https://pypi.python.org/project/compas_view2)
  [![Conda - Latest Release](https://anaconda.org/conda-forge/compas_view2/badges/version.svg)](https://anaconda.org/conda-forge/compas_view2)
  [![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/compas_view2)](https://anaconda.org/conda-forge/compas_view2)

  Second generation viewers for the COMPAS framework.




  -   Full support for all COMPAS objects (primitives, shapes, network, mesh, volmesh)
  -   Pick select and Box select
  -   Shaded, Ghosted, Wireframe, Specular visualization modes
  -   Mesh faces with individual colors
  -   Dynamic visualization with simple decorators
  -   Text annotations
  -   Customizable UI and UI Controller
  -   Transformations in object space
  -   ...



  See the [Getting Started](https://compas.dev/compas_view2/latest/gettingstarted.html) instructions in the docs.



  This [tutorial page](https://compas.dev/compas_view2/latest/tutorials.html) contains basic lead-through, configuration setting, and software concepts.



  Examples can be found in our [example page](https://compas.dev/compas_view2/latest/examples.html).



  The code in this repo is licensed under the [MIT License](LICENCSE).



  Please check the [Issue Tracker](https://github.com/compas-dev/compas_view2/issues) of the repo for known issues and their solutions.



  This project targets to [compas](https://github.com/compas-dev/compas). The next generation of it with compas_2 compatibility can be found in a separate repo [here](https://github.com/compas-dev/compas_viewer).


pkgId: 0cc5a3a1a6fa8f757c28e62e6fbb4a168ac99a143e8f61b211089a231850423a
name: python-compas-viewer
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Standalone viewer for COMPAS 2 based on PyOpenGL and PyQt6.
url: https://compas-dev.github.io/compas_viewer
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compas-viewer-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Standalone viewer for COMPAS 2.0

  More information is available in the docs: <https://compas.dev/compas_viewer/>



  - Performative and easy-to-use new architecture based on [compas_v1](https://compas.dev/compas/1.17.9/)'s [compas_view2](https://compas.dev/compas_view2/).
  - Complete configurable settings and flexible customization.
  - Full support for all COMPAS objects (primitives, shapes, graph, mesh, volmesh) based on [compas.scene](https://compas.dev/compas/latest/api/generated/compas.scene.Scene.html#scene) architecture.
  - Up-to-date [PySide6](https://pypi.org/project/PySide6/) and [PyOpenGL](https://pypi.org/project/PyOpenGL/) compatibility.
  - Action-based user interaction: drag, select, zoom, pan, rotate, etc.
  - Data-driven visualization with simple decorators: facecolor, edgecolor, vertexcolor, linewidth, pointsize, etc.
  - Text tags and grids.
  - Customizable UI and UI Controller
  - Transformations in object space
  - ...



  See the [Getting Started](https://compas.dev/compas_viewer/latest/gettingstarted.html) instructions in the docs.



  This [tutorial page](https://compas.dev/compas_viewer/latest/tutorials.html) contains basic lead-through, configuration setting, and software concepts.



  Examples can be found in our [example page](https://compas.dev/compas_viewer/latest/examples.html).



  [Contributing page](CONTRIBUTING.md) provides the guidelines for contributing to this project. We very much welcome any contributions to this project (Bug Fix, Action class contribution, etc.)



  The code in this repo is licensed under the [MIT License](LICENCSE).



  Please check the [Issue Tracker](https://github.com/compas-dev/compas_viewer/issues) of the repo for known issues and their solutions.

rpm_license:
  MIT License  COMPAS Association  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: 27f053a0f25b6a8a8176e112f5ebfdad4ac8ba00e225d5deffb09ad71dcd16db
name: python-compatibility
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/RuedigerVoigt/compatibility
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compatibility-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  A library that checks whether the running version of Python is compatible and tested. Remind the user to check for updates of the library.

description:
  ![Supported Python Versions](https://img.shields.io/pypi/pyversions/compatibility)
  ![pypi version](https://img.shields.io/pypi/v/compatibility)
  ![Last commit](https://img.shields.io/github/last-commit/RuedigerVoigt/compatibility)
  [![Coverage](https://img.shields.io/badge/coverage-99%25-brightgreen)](https://www.ruediger-voigt.eu/coverage/compatibility/index.html)
  [![Downloads](https://pepy.tech/badge/compatibility/month)](https://pepy.tech/project/compatibility)

  Compatibility is a simple tool designed to be used by package authors. It does five things:
  * Check whether the running Python interpreter version is supported, i.e. equal or higher than the minimum version and not in a list of incompatible versions. Raises a `RuntimeError` exception if the interpreter version is marked as incompatible.
  * Log a warning if the running interpreter version is higher than the highest version used in tests.
  * Log an info message with package name, version, and release date.
  * Log an info message asking the user to check for updates if a defined number of days has passed since release. (For privacy reason it is not checked whether a new version is actually available.)
  * Check whether the operating system group (i.e. Linux, MacOS, or Windows) is fully supported, partially supported or marked as incompatible. Partial supports logs an info message, while incompatibility yields an exception.

  The prepared messages are available in English and German.

  For these tasks it does not need any dependencies outside the Python standard library. The code has type hints ([PEP 484](https://www.python.org/dev/peps/pep-0484/)).



  ```bash
  sudo pip3 install compatibility
  ```



  It is important, that you **do NOT call `compatibility` in the `__init__.py` file of your package, but in the constructor (`def __init__()`) of your class instead.** If you start the check in the `__init__.py` file, then it will run once you *import* the package. This goes well *if* the user already set the level for `logging`. If that is not the case, the user will see all messages including those on the `DEBUG` level. This is not a problem if the check is done in the constructor.

  As an example the relevant parts of the constructor of the [salted](https://github.com/RuedigerVoigt/salted) package:

  ```python

  from datetime import date
  import logging


  import compatibility



  class Salted:
      """Main class. Creates the other Objects, starts workers,
         collects results and starts the report of results. """

      VERSION = '0.6.1'

      def __init__(self,
                   [...]) -> None:

          compatibility.Check(
              package_name='salted',
              package_version=self.VERSION,
              release_date=date(2021, 1, 17),
              python_version_support={
                  'min_version': '3.8',
                  'incompatible_versions': ['3.7'],
                  'max_tested_version': '3.9'},
              nag_over_update={
                      'nag_days_after_release': 30,
                      'nag_in_hundred': 50},
              language_messages='en',
              system_support={
                  'full': {'Linux', 'MacOS', 'Windows'}
              })
  ```
  The salted package has an actual problem with 3.7 and must not be run with this version. So these settings throw a `RuntimeError` in case someone tries.
  Salted in that specific version is a relatively young package that will receive frequent updates. So beginning a month after the release this will nag the user over looking for an update every second time - provided the user activated logging.



  * `package_name` (required): the name of your package.
  * `package_version` (required): the version number of your package as a string.
  * `release_date` (required): requires a `datetime` object (like `date(2021,1,1)`), or a string in the exact format `YYYY-MM-DD`.
  * `python_version_support` (optional): requires a dictionary with the three following keys:
      * `min_version`: a string with the number of the oldest supported version (like `'3.6'`).
      * `incompatible_versions`: a list of incompatible versions that will raise the `RuntimeError`exception if they try to run your package.
      * `max_tested_version`: the latest version of the interpreter you successfully tested your code with.
  * `nag_over_update` (optional): requires a dictionary with the three following keys:
      * `nag_days_after_release`: wait this number of days (`int`) since the release before reminding users to check for an update.
      * `nag_in_hundred`: Whether to nag over a possible update is random, but this sets the probability in the form how many times (int) out of hundred starts the message is logged. Accordingly 100 means every time.
  * `language_messages` (optional): the language (`en` for English or `de` for German) of the messages logged by this. Defaults to English log messages.
  * `system_support` (optional): allows you to state the level of compatibility between your code and different Operating System groups. This is purposefully done on a very high level: valid inputs are only 'Linux', 'MacOS', and 'Windows' and not specific versions and distributions. The dictionary allows three keys with a set as value each:
      * `full`: The set of operating systems that are tested on production level.
      * `partial`: The set of systems that should work, but are not as rigorously tested as those with full support. A system running found here logs a warning.
      * `incompatible`: The set of systems of which you know they will fail to run the code properly. If an OS in this set tries to run the code, this will yield a `RuntimeError` exception.



  For compatibility checks three elements of the version string are recognized:
  * The major version
  * The minor version
  * The release level (either alpha, beta, candidate, or final)

  If you provide all three elements (for example `'3.10.alpha'`) only this very specific version will be matched. If you provide only the first two (in this case `'3.10'`), all release levels of this version will match.
  So assume your code would have issues with Python 3.5.beta and you list that exact string as an incompatible version. If you are running the script under 3.5.alpha nothing will happen. If you listed it by using the string `'3.5'` running the script with 3.5.alpha (or any other release level of 3.5) will raise the `RuntimeError` exception.

  However, `min_version` and `max_tested_version` ignore the release level part.



  In the `setup.py` file of your package you can use the [python_requires](https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires) parameter to tell `pip` about incompatible versions of the interpreter. This should block installation on incompatible systems. However, users can circumvent this by setting the flag `--python-version`. More likely is a system upgrade, that installs an incompatible version with the systems package manager.

  If you define incompatible versions while initializing the `compatibility` package, you add another layer of control. Even if your user ended up with an incompatible interpreter, that will trigger a `RuntimeError` exception once the user tries to run your package.


pkgId: 005b5728c27ef102b2f9b5e4eb43374a157eb34a369d4582a8ccd62b4a0603ca
name: python-compatibleversion
arch: src
version: 0.2.17
epoch: 0
release: 1
summary: Determine compatibility given a version and specifier
url: https://github.com/plus3it/compatibleversion
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compatibleversion-0.2.17-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/YakDriver/compatibleversion.svg)](./LICENSE)
  [![Travis CI Build Status](https://travis-ci.org/YakDriver/compatibleversion.svg)](https://travis-ci.org/YakDriver/compatibleversion)
  [![Latest Version](https://img.shields.io/pypi/v/compatibleversion.svg?label=version)](https://pypi.python.org/pypi/compatibleversion)



  *compatibleversion* takes two parameters, a version and a specifier (i.e., version constraints), and returns a Boolean value indicating compatibility.

  **NOTE:** *compatibleversion* wraps [packaging](https://packaging.pypa.io/en/latest/) in order to simplify and test its use. Versions and specifiers provided to *compatibleversion* must conform to [PEP 440](https://www.python.org/dev/peps/pep-0440/) as required by *packaging*.



  ```console
  $ pip install compatibleversion
  ```



  Use *compatibleversion* in Python code:

  ```python
  from compatibleversion import check_version

  check_version('1.3.0', '> 1.2, < 3.3')          # True
  check_version('2.1', '~= 2.2')                  # False

  check_version('1.1.dev0', '>=1.0')              # True
  check_version('1.1.dev0', '>=1.0', False)       # False, not allowing pre/dev-final comparison

  check_version('1.1.dev0', '>=1.0.dev0')         # True, dev-dev compare
  check_version('1.1.dev0', '>=1.0.dev0', False)  # True, doesn't affect since dev-dev
  ```



  The version parameter must conform to [PEP 440](https://www.python.org/dev/peps/pep-0440/). These are examples of valid version parameters:

  ```
  1.2.0
  0.0.0
  0.9
  0.9.1
  0.9.2
  0.9.10
  0.9.11
  1.0
  1.0.1
  1.1
  2.0
  2.0.1
  1.0a1
  1.0a2
  1.0b1
  1.0rc1
  1.0.dev1
  1.0.dev2
  1.0.dev3
  1.0.dev4
  1.0b2.post345.dev456
  1.0b2.post345
  1.0rc1.dev456
  ```



  The version specifier parameter must conform to [PEP 440](https://www.python.org/dev/peps/pep-0440/). The specifier consists of one or more version clauses separated by commas.

  For example, these are valid version specifiers (the last two are approximately equivalent):

  ```
  ==1.0.1
  < 1.2, > 1.3
  ~= 0.9, >= 1.0, != 1.3.4.*, < 2.0
  ~= 1.4.5.0
  == 1.1.post1
  ~= 2.2
  >= 2.2, == 2.*
  ```

  Here are more helpful specifier examples from [PEP 440](https://www.python.org/dev/peps/pep-0440/) and an explanation of their meaning:

  * `~=3.1`: version 3.1 or later, but not version 4.0 or later.
  * `~=3.1.2`: version 3.1.2 or later, but not version 3.2.0 or later.
  * `~=3.1a1`: version 3.1a1 or later, but not version 4.0 or later.
  * `== 3.1`: specifically version 3.1 (or 3.1.0), excludes all pre-releases, post releases, developmental releases and any 3.1.x maintenance releases.
  * `== 3.1.*`: any version that starts with 3.1. Equivalent to the ~=3.1.0 compatible release clause.
  * `~=3.1.0, != 3.1.3`: version 3.1.0 or later, but not version 3.1.3 and not version 3.2.0 or later.





  **Commit Delta**: [Change from 0.1.3 release](https://github.com/plus3it/watchmaker/compare/0.1.3...0.2.0)

  **Released**: 2020.03.04

  **Summary**:

  *   Allow comparison between prerelease and dev releases (e.g., `1.0.dev0`) and final releases (e.g., `1.0`)



  **Commit Delta**: [Change from 0.1.2 release](https://github.com/plus3it/watchmaker/compare/0.1.2...0.1.3)

  **Released**: 2020.01.28

  **Summary**:

  *   Update dependencies
  *   Update Python compatibility versions in PyPI/wheel package



  **Commit Delta**: [Change from 0.1.1 release](https://github.com/plus3it/watchmaker/compare/0.1.1...0.1.2)

  **Released**: 2019.10.24

  **Summary**:

  *   Improve compatibility with Py2.6



  **Commit Delta**: [Change from 0.1.0 release](https://github.com/plus3it/watchmaker/compare/0.1.0...0.1.1)

  **Released**: 2019.10.24

  **Summary**:

  *   Minor CI changes
  *   Add documentation



  **Commit Delta**: [Change from 0.0.0 release](https://github.com/plus3it/watchmaker/compare/0.0.0...0.1.0)

  **Released**: 2019.10.22

  **Summary**:

  *   Initial release


pkgId: da41c84e2f0c1ec0ff9839211e450d160b5c3261470d755108b85f33152f9120
name: python-compatlib
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: Helper tool to install and configure Flux Framework
url: https://github.com/compspec/compat-lib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compatlib-0.0.0-1.src.rpm
checksum_type: sha256
description:
  > Python helpers for compat-lib set of tools in Go

  ![PyPI - Version](https://img.shields.io/pypi/v/compatlib)

  This library provides parsers and models for filesystem recording (fs-record) output from the associated Go tooling.
  For more information, see the [main README](https://github.com/compspec/compat-lib).



  HPCIC DevTools is distributed under the terms of the MIT license.
  All new contributions must be made under this license.

  See [LICENSE](https://github.com/converged-computing/cloud-select/blob/main/LICENSE),
  [COPYRIGHT](https://github.com/converged-computing/cloud-select/blob/main/COPYRIGHT), and
  [NOTICE](https://github.com/converged-computing/cloud-select/blob/main/NOTICE) for details.

  SPDX-License-Identifier: (MIT)

  LLNL-CODE- 842614


pkgId: d5bb2c43da365b50e241f58ff4bfff8bc1f83857b6c885d89e648b24cc53e7fe
name: python-compel
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: A prompting enhancement library for transformers-type text embedding systems.
url: https://github.com/damian0815/compel
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compel-2.0.3-1.src.rpm
checksum_type: sha256
description:
  A text prompt weighting and blending library for transformers-type text embedding systems, by [@damian0815](https://github.com/damian0815).

  With a flexible and intuitive syntax, you can re-weight different parts of a prompt string and thus re-weight the different parts of the embedding tensor produced from the string.

  Tested and developed against Hugging Face's `StableDiffusionPipeline` but it should work with any diffusers-based system that uses an `Tokenizer` and a `Text Encoder` of some kind.

  Adapted from the [InvokeAI](https://github.com/invoke-ai) prompting code (also by [@damian0815](https://github.com/damian0815)).

  Note that cross-attention control `.swap()` is currently ignored by Compel, but you can use it by calling `build_conditioning_tensor_for_prompt_object()` yourself, and implementing cross-attention control in your diffusion loop.



  `pip install compel`



  Documentation is [here](doc/).



  See [compel-demo.ipynb](compel-demo.ipynb)

  <a target="_blank" href="https://colab.research.google.com/github/damian0815/compel/blob/main/compel-demo.ipynb">
    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
  </a>



  with Hugging Face diffusers >=0.12:

  ```python
  from diffusers import StableDiffusionPipeline
  from compel import Compel

  pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
  compel = Compel(tokenizer=pipeline.tokenizer, text_encoder=pipeline.text_encoder)


  prompt = "a cat playing with a ball++ in the forest"
  conditioning = compel.build_conditioning_tensor(prompt)



  images = pipeline(prompt_embeds=conditioning, num_inference_steps=20).images
  images[0].save("image.jpg")
  ```

  For batched input, use the __call__ interface to compel:

  ```python
  from diffusers import StableDiffusionPipeline
  from compel import Compel

  pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
  compel = Compel(tokenizer=pipeline.tokenizer, text_encoder=pipeline.text_encoder)

  prompts = ["a cat playing with a ball++ in the forest", "a dog playing with a ball in the forest"]
  prompt_embeds = compel(prompts)
  images = pipeline(prompt_embeds=prompt_embeds).images

  images[0].save("image0.jpg")
  images[1].save("image1.jpg")
  ```



  If you want to have access to 🤗diffusers textual inversions, instantiate a `DiffusersTextualInversionManager` and pass it on Compel init:

  ```
  pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
  textual_inversion_manager = DiffusersTextualInversionManager(pipeline)
  compel = Compel(tokenizer=pipeline.tokenizer, text_encoder=pipeline.text_encoder,
      textual_inversion_manager=textual_inversion_manager)
  ```



  If you run into memory issues, please make sure you're running compel inside `with torch.no_grad():` blocks.

  If this doesn't help, you could try this advice offered by @kshieh1:
  > After image generation, you should explictly de-reference the tensor object (i.e., prompt_embeds = None) and call gc.collect()

  See https://github.com/damian0815/compel/issues/24 for more details. Thanks @kshieh1 !











  With big thanks to Patrick von Platen from Hugging Face for [the pull request](https://github.com/damian0815/compel/pull/41), Compel now supports SDXL. Use it like this:

  ```py
  from compel import Compel, ReturnedEmbeddingsType
  from diffusers import DiffusionPipeline
  import torch

  pipeline = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", variant="fp16", use_safetensors=True, torch_dtype=torch.float16).to("cuda")
  compel = Compel(tokenizer=[pipeline.tokenizer, pipeline.tokenizer_2] , text_encoder=[pipeline.text_encoder, pipeline.text_encoder_2], returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED, requires_pooled=[False, True])

  prompt = "a cat playing with a ball++ in the forest"
  conditioning, pooled = compel(prompt)

  image = pipeline(prompt_embeds=conditioning, pooled_prompt_embeds=pooled, num_inference_steps=30).images[0]
  ```

  Please note that this is a **breaking change** if you've been using clip skip: the old boolean arg `use_penultimate_clip_layer` has been replaced with an enum `ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NORMALIZED`.






  For Stable Diffusion 2.1 I've been experimenting with a new feature: concatenated embeddings. What I noticed, for example, is that for more complex prompts image generation quality becomes wildly better when the prompt is broken into multiple parts and fed to OpenCLIP separately.

  TL;DR: you can now experiment with breaking up your prompts into segments, which for SD2.1 appears to improve the generated image. The syntax is `("prompt part 1", "prompt part 2").and()`. You can have more than one part, and you can also weight them, eg `("a man eating an apple", "sitting on the roof of a car", "high quality, trending on artstation, 8K UHD").and(1, 0.5, 0.5)` which will assign weight `1` to `man eating an apple` and `0.5` to `sitting on the roof of a car` and `high quality, trending on artstation, 8K UHD`.

  Here's a nonsense example from the InvokeAI discord #garbage-bin channel, created by gogurt enjoyer's incredible [nightmare prompt generator](https://huggingface.co/cactusfriend/nightmare-invokeai-prompts):

  ```
  a moist sloppy pindlesackboy sloppy hamblin' bogomadong, Clem Fandango is pissed-off, Wario's Woods in background, making a noise like ga-woink-a
  ```

  Plugging this straight into SD2.1 we get this, which is really not a good image:
  ![](images/000075.6dfd7adf.466129594.png)

  However, if the prompt is broken up into chunks and fed into OpenCLIP separately as four separate prompts, and then concatenated:

  ```
  a moist sloppy pindlesackboy sloppy hamblin' bogomadong

  Clem Fandango is pissed-off

  Wario's Woods in background

  making a noise like ga-woink-a
  ```

  then output image with the same seed is *so much* better:
  ![](images/000076.68b1c320.466129594.png)

  In the new `.and()` syntax you would prompt this as follows:
  ```
  ("a moist sloppy pindlesackboy sloppy hamblin' bogomadong", "Clem Fandango is pissed-off", "Wario's Woods in background", "making a noise like ga-woink-a").and()
  ```

  The effect can be more or less subtle. Here for example is
  ```
  A dream of a distant galaxy, by Caspar David Friedrich, matte painting, trending on artstation, HQ
  ```
  ![](images/000129.1b33b559.2793529321.png)

  And the same split into two parts:
  ```
  A dream of a distant galaxy, by Caspar David Friedrich, matte painting

  trending on artstation, HQ
  ```
  ![](images/000128.b5d5cd62.2793529321.png)

  The Compel prompt for this is:
  ```
  ("A dream of a distant galaxy, by Caspar David Friedrich, matte painting", "trending on artstation, HQ").and()
  ```





  - add `DiffusersTextualInversionManager` (thanks @pdoane)
  - fix batch embedding generation with truncated/non-truncated prompt lengths (#18, thanks @abassino)
  - add note about memory leakage (ref #24, thanks @kshieh1)
  - fix incorrect parsing when commas are not followed by whitespace (#34, thanks @moono)







  To use, pass `use_penultimate_clip_layer=True` when initializing your `Compel` instance. Note that there's no need to pass this flag for SD2.0/SD2.1 because diffusers already throws away the last hidden layer when loading the SD2.0+ text encoder.







  * `Compel.parse_prompt_string()` now returns a `Conjunction`
  * any appearances of `withLora(name[, weight])` or `useLora(name[, weight])` anywhere in the prompt string will be parsed to `LoraWeight` instances, and returned on the outermost `Conjunction` returned by `parse_prompt_string()`.



  also fix test case for default swap parameters











  Downweighting now works by applying an attention mask to remove the downweighted tokens, rather than literally removing them from the sequence. This behaviour is the default, but the old behaviour can be re-enabled by passing `downweight_mode=DownweightMode.REMOVE` on init of the `Compel` instance.

  Formerly, downweighting a token worked by both multiplying the weighting of the token's embedding, and doing an inverse-weighted blend with a copy of the token sequence that had the downweighted tokens removed. The intuition is that as weight approaches zero, the tokens being downweighted should be actually removed from the sequence. However, removing the tokens resulted in the positioning of all downstream tokens becoming messed up. The blend ended up blending a lot more than just the tokens in question.

  As of v1.0.0, taking advice from @keturn and @bonlime (https://github.com/damian0815/compel/issues/7) the procedure is by default different. Downweighting still involves a blend but what is blended is a version of the token sequence with the downweighted tokens masked out, rather than removed. This correctly preserves positioning embeddings of the other tokens.

  Also a bugfix: fix black images on weight 0 (https://github.com/invoke-ai/InvokeAI/issues/2832)



  To enable, initialize `Compel` with `truncate_long_prompts=False` (default is True). Prompts that are longer than the model's `max_token_length` will be chunked and padded out to an integer multiple of `max_token_length`.

  Note that even if you don't use a negative prompt, you'll need to build a conditioning tensor for a negative prompt of at least `""`, and use `compel.pad_conditioning_tensors_to_same_length()`, otherwise the you'll get an error about mismatched conditioning tensor lengths:

  ```python
  compel = Compel(..., truncate_long_prompts=False)
  prompt = "a cat playing with a ball++ in the forest, amazing, exquisite, stunning, masterpiece, skilled, powerful, incredible, amazing, trending on gregstation, greg, greggy, greggs greggson, greggy mcgregface, ..." # very long prompt
  conditioning = compel.build_conditioning_tensor(prompt)
  negative_prompt = "" # it's necessary to create an empty prompt - it can also be very long, if you want
  negative_conditioning = compel.build_conditioning_tensor(negative_prompt)
  [conditioning, negative_conditioning] = compel.pad_conditioning_tensors_to_same_length([conditioning, negative_conditioning])
  ```


pkgId: 7410df5c6690abadb3910b970ba194ea8798c68e29137e3de03ab17f2cf1abee
name: python-compendium
arch: src
version: 0.1.3.post9
epoch: 0
release: 1
summary: Simple layered configuraion tool
url: https://pypi.org/project/compendium/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compendium-0.1.3.post9-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Build Status](https://travis-ci.org/kuwv/python-compendium.svg?branch=master)](https://travis-ci.org/kuwv/python-compendium)
  [![codecov](https://codecov.io/gh/kuwv/python-compendium/branch/master/graph/badge.svg)](https://codecov.io/gh/kuwv/python-compendium)



  Compendium is a layered configuration management tool. It has the capability
  to manage configuration files writen in JSON, TOML, XML and YAML. Settings
  from these configuration files can then be managed easily with the help of
  dpath.



  https://kuwv.github.io/python-compendium/



  ```
  pip install compendium
  ```



  ```python
  >>> import os
  >>> from compendium import ConfigFile

  >>> basedir = os.path.join(os.getcwd(), 'tests')
  >>> filepath = os.path.join(basedir, 'config.toml')

  >>> cfg = ConfigFile(filepath)
  >>> settings = cfg.load()

  Simple lookup for title
  >>> settings['/title']
  'TOML Example'

  Query values within list
  >>> settings.values('/servers/**/ip')
  ['10.0.0.1', '10.0.0.2']

  Check the current server IP address
  >>> settings['/database/server']
  '192.168.1.1'

  Update the server IP address
  >>> settings['/database/server'] = '192.168.1.2'
  >>> settings['/database/server']
  '192.168.1.2'

  Check the database max connections
  >>> settings['/database/connection_max']
  5000

  Delete the max connections
  >>> del settings['/database/connection_max']

  Check that the max connections have been removed
  >>> settings.get('/database/connection_max')

  ```



  The `ConfigManager` is a layered dictionary mapping. It allows multiple
  configurations to be loaded from various files. Settings from each file
  is overlapped in order so that the first setting found will be used.

  ```python
  >>> import os

  >>> from compendium import ConfigManager

  Reference config files from examples
  >>> basedir = os.path.join(os.getcwd(), 'examples', 'config_manager')
  >>> config1 = os.path.join(basedir, 'config1.toml')
  >>> config2 = os.path.join(basedir, 'config2.toml')

  Retrieve settings from config files
  >>> cfg = ConfigManager(name='app', filepaths=[config1, config2])

  Get using dpath
  >>> cfg.get('/default/foo2')
  'bar2'

  Lookup with multi-query
  >>> cfg.lookup('/example/settings/foo', '/default/foo')
  'baz'

  ```



  ```python
  >>> import os

  >>> from anytree import RenderTree
  >>> from compendium.config_manager import ConfigManager, TreeConfigManager

  >>> basedir = os.path.join(os.getcwd(), 'examples', 'tree')

  >>> cfg = TreeConfigManager(
  ...     name='fruit',
  ...     basedir=basedir,
  ...     filename='node.toml',
  ...     load_root=True,
  ...     load_children=True,
  ... )

  >>> cfg.defaults == {}
  True

  >>> 'succulant' in cfg['/fruit/children']
  True

  >>> succulant = cfg.get_config('/fruit/succulant')
  >>> succulant.name
  'succulant'

  ```



  TBD
  <!--








































  -->



  ```
  python -m venv .vev
  pip install -e .[dev]
  python -m doctest README.md
  ```

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


pkgId: 5ea9a8a7775c38ff92f6ae82284a7ff0800afa31cc6bf9f6c02446cb7a304549
name: python-competitive-verifier
arch: src
version: 3.2.2
epoch: 0
release: 1
summary: Verifier for libraries of competitive programming
url: https://github.com/competitive-verifier/competitive-verifier
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-competitive-verifier-3.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/competitive-verifier/competitive-verifier/actions/workflows/verify.yml/badge.svg)](https://github.com/competitive-verifier/competitive-verifier/actions) [![GitHub Pages](https://img.shields.io/static/v1?label=GitHub+Pages&message=+&color=brightgreen&logo=github)](https://competitive-verifier.github.io/competitive-verifier)
  [![PyPI](https://img.shields.io/pypi/v/competitive-verifier)](https://pypi.org/project/competitive-verifier/)

  The library is inspired by [online-judge-tools/verification-helper](https://github.com/online-judge-tools/verification-helper).

  - [Getting Started](https://competitive-verifier.github.io/competitive-verifier/installer.html) / [日本語](https://competitive-verifier.github.io/competitive-verifier/installer.ja.html)
  - [Reference](https://competitive-verifier.github.io/competitive-verifier/document.html) / [日本語](https://competitive-verifier.github.io/competitive-verifier/document.ja.html)
  - [DESIGN(日本語)](https://competitive-verifier.github.io/competitive-verifier/DESIGN)






  See [GitHub Pages](https://competitive-verifier.github.io/competitive-verifier/installer.html).
  [日本語](https://competitive-verifier.github.io/competitive-verifier/installer.ja.html)





  Needs Python 3.9 or greater.

  ```sh
  pip install competitive-verifier
  ```

  Or

  ```sh
  pip install git+https://github.com/competitive-verifier/competitive-verifier.git@latest
  ```

  **Migrate from verification-helper**

  Run this script.

  ```sh
  competitive-verifier migrate
  ```



  ```sh
  pip install -U poetry
  poetry install


  poetry run pytest


  poetry run poe format
  ```


pkgId: 73b836a7d713557975d96cd6e9f4a24ef737687626df62769e06bc32c4987588
name: python-compiledb
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Tool for generating Clang JSON Compilation Database files for make-based build systems.
url: https://github.com/nickdiego/compiledb
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compiledb-0.10.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI branch](https://img.shields.io/circleci/project/github/nickdiego/compiledb/master.svg)](https://circleci.com/gh/nickdiego/compiledb)
  [![PyPI](https://img.shields.io/pypi/v/compiledb.svg)](https://pypi.org/project/compiledb/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compiledb.svg)](https://pypi.org/project/compiledb)
  [![GitHub](https://img.shields.io/github/license/nickdiego/compiledb.svg)](https://github.com/nickdiego/compiledb/blob/master/LICENSE)

  Tool for generating [Clang's JSON Compilation Database][compdb] file for GNU
  `make`-based build systems.

  It's aimed mainly at non-cmake (cmake already generates compilation database)
  large codebases. Inspired by projects like [YCM-Generator][ycm-gen] and [Bear][bear],
  but faster (mainly with large projects), since in most cases it **doesn't need a clean
  build** (as the mentioned tools do) to generate the compilation database file, to
  achieve this it uses the make options such as `-n`/`--dry-run` and `-k`/`--keep-going`
  to extract the compile commands. Also, it's more **cross-compiling friendly** than
  YCM-generator's fake-toolchanin approach.



  ```

  ```
  - Supports Python 2.x and 3.x (for now, tested only with 2.7 and 3.6 versions)
  - For bash completion support, add the content of `sh-completion/compiledb.bash` file
    to your `.bashrc` file, for example.
  - _ZSH completion coming soon :)_



  `compiledb` provides a `make` python wrapper script which, besides to execute the make
  build command, updates the JSON compilation database file corresponding to that build,
  resulting in a command-line interface similar to [Bear][bear].

  To generate `compile_commands.json` file using compiledb's "make wrapper" script,
  executing Makefile target `all`:
  ```bash
  $ compiledb make
  ```

  `compiledb` forwards all the options/arguments passed after `make` subcommand to GNU Make,
  so one can, for example, generate `compile_commands.json` using `core/main.mk`
  as main makefile (`-f` flag), starting the build from `build` directory (`-C` flag):
  ```bash
  $ compiledb make -f core/main.mk -C build
  ```

  By default, `compiledb make` generates the compilation database and runs the actual build
  command requested (acting as a make wrapper), the build step can be skipped using the `-n`
  or `--no-build` options.
  ```bash
  $ compiledb -n make
  ```

  `compiledb` base command has been designed so that it can be used to parse compile commands
  from arbitrary text files (or stdin), assuming it has a build log (ideally generated using
  `make -Bnwk` command), and generates the corresponding JSON Compilation database.

  For example, to generate the compilation database from `build-log.txt` file, use the following
  command.
  ```bash
  $ compiledb --parse build-log.txt
  ```

  or its equivalent:
  ```bash
  $ compiledb < build-log.txt
  ```

  Or even, to pipe make's output and print the compilation database to the standard output:
  ```bash
  $ make -Bnwk | compiledb -o-
  ```

  By default `compiledb` generates a JSON compilation database in the "arguments" list
  [format](https://clang.llvm.org/docs/JSONCompilationDatabase.html). The "command" string
  format is also supported through the use of the `--command-style` flag:
  ```bash
  $ compiledb --command-style make
  ```



  I've implemented this tool because I needed to index some [AOSP][aosp]'s modules for navigating
  and studying purposes (after having no satisfatory results with current tools available by the
  time such as [YCM-Generator][ycm] and [Bear][bear]). So I've reworked YCM-Generator, which resulted
  in the initial version of [compiledb/parser.py](compiledb/parser.py) and used successfully to generate
  `compile_commands.json` for some AOSP modules in ~1min running in a [Docker][docker] container and then
  could use it with some great tools, such as:

  - [Vim][vim] + [YouCompleteMe][ycm] + [rtags][rtags] + [chromatica.nvim][chrom]
  - [Neovim][neovim] + [LanguageClient-neovim][lsp] + [cquery][cquery] + [deoplete][deoplete]
  - [Neovim][neovim] + [ALE][ale] + [ccls][ccls]

  Notice:
  - _Windows: tested on Windows 10 with cmd, wsl(Ubuntu), mingw32_
  - _Linux: tested only on Arch Linux and Ubuntu 18 so far_
  - _Mac: tested on macOS 10.13 and 10.14_

  Patches are always welcome :)


  GNU GPLv3

  [compdb]: https://clang.llvm.org/docs/JSONCompilationDatabase.html
  [ycm]: https://github.com/Valloric/YouCompleteMe
  [rtags]: https://github.com/Andersbakken/rtags
  [chrom]: https://github.com/arakashic/chromatica.nvim
  [ycm-gen]: https://github.com/rdnetto/YCM-Generator
  [bear]: https://github.com/rizsotto/Bear
  [aosp]: https://source.android.com/
  [docker]: https://www.docker.com/
  [vim]: https://www.vim.org/
  [neovim]: https://neovim.io/
  [lsp]: https://github.com/autozimu/LanguageClient-neovim
  [cquery]: https://github.com/cquery-project/cquery
  [deoplete]: https://github.com/Shougo/deoplete.nvim
  [ccls]: https://github.com/MaskRay/ccls
  [ale]: https://github.com/w0rp/ale


pkgId: e6876d59046558b048ed4432b8e8728fc906459f78b6c35b3743923aa185ce72
name: python-compiler
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A data integrity check library
url: https://github.com/xiaojieluo/vlde
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compiler-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Copyright (c) 2017 罗小杰

  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.

  Description: # auto compiler

          根据文件名自动编译运行程序

  Keywords: Automatically compile code based on file type
  Platform: UNKNOWN
  Classifier: Development Status :: 4 - Beta
  Classifier: Intended Audience :: Developers
  Classifier: Natural Language :: English
  Classifier: License :: OSI Approved :: Apache Software License
  Classifier: Programming Language :: Python
  Classifier: Programming Language :: Python :: 3
  Classifier: Programming Language :: Python :: 3.3
  Classifier: Programming Language :: Python :: 3.4
  Classifier: Programming Language :: Python :: 3.5
  Classifier: Programming Language :: Python :: 3.6
  Classifier: Programming Language :: Python :: Implementation :: CPython
  Classifier: Programming Language :: Python :: Implementation :: PyPy
  Requires-Python: >=3


pkgId: 2413a66ff7b2d07ac694c1782c7c4737d6d3b2f4cbf74034c35f9fe66a061630
name: python-compipe
arch: src
version: 0.2.18
epoch: 0
release: 1
summary: a lite version of the command wrapper for python
url: https://github.com/ImagineersHub/compipe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compipe-0.2.18-1.src.rpm
checksum_type: sha256
description:
  Compipe is a lightweight command manager specifically designed to automate tasks.




  ```python

  credentials_cfg_path = os.path.join(os.path.dirname(__file__), 'credential/keys.json')

  runtime_cfg_path = os.path.join(os.path.dirname(__file__), 'tars_server_runtime_env.json')


  initialize_runtime_environment(params={ARG_DEBUG: False},
                                 runtime_cfg_path=runtime_cfg_path,
                                 credential_cfg_path=credentials_cfg_path)


  ```



  - Add "entry_points" to setup.py
    ```text
      setup(
          
          entry_points={
              'console_scripts': [
                  'unittest = compipe.unittest.cmd_test:main',
              ],
          }
      )

    ```
  - Install Your Package in Editable Mode:
    ```text
    pip install -e .
    ```

  - Add PYPI API token to system environment
    ```text
    set PYPI_API_TOKEN=<Your-API-Token>
    ```
  - Run `upload.bat` to upload package wheel


pkgId: d1c64d1e474dbe19c9707b2e885b444eb7fb1162f0aeed1ce83631fec41e4859
name: python-completor
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Advanced mulit-segmented well completion tool.
url: https://github.com/equinor/completor
rpm_license: LGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-completor-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Completor® is an Equinor developed Python Command Line Interface (CLI) for modeling wells with inflow control technology.


  Completor® reads the multi-segmented tubing definition generated by reservoir modelling pre-processing tool and a user defined file (called "case" file) specifying the completion design.
  The information in the input schedule file and the case file is combined
  and written to a new schedule file to be included in your reservoir simulator.


  Detailed documentation for usage of completor can be found at https://equinor.github.io/completor.




  * [Python](https://www.python.org/), version 3.11
  * [ERT](https://github.com/equinor/ert) (optional, and only available on Linux.)


  To start using Completor®, you can follow these instructions:

  ```shell
  git clone https://github.com/equinor/completor.git
  cd completor
  python3 -m venv venv
  source venv/bin/activate
  pip install -e .
  ```

  If you intend to run completor as a plugin to ert:
  ```shell
  git clone https://github.com/equinor/completor.git
  cd completor
  python -m venv venv
  source venv/bin/activate
  pip install -e ".[ert]"
  ```

  Ensure it runs as intended, confirm it with:
  ```shell
  completor --help
  ```
  This should run for some time and display a help message.


  Some examples of Completor case file are available in [Examples](documentation/docs/about/examples.mdx) and detailed explanation is available in [Configuration](documentation/docs/about/configuration.mdx).



  We welcome all kinds of contributions, including code, bug reports, issues, feature requests, and documentation.
  The preferred way of submitting a contribution is to either make an issue on GitHub or by forking the project on GitHub
  and making a pull request.

  See [Contribution Document](documentation/docs/contribution_guide.mdx) on how to contribute.


  In order to run Completor® you need to have versions of [Python 3.11](https://www.python.org/downloads/) installed.

  Clone the [Completor® repository](https://github.com/equinor/completor) to get the source code.
  ```bash
  git clone https://github.com/equinor/completor.git
  cd completor
  ```


  [Install pipx](https://github.com/pypa/pipx#install-pipx), although it's optional next step assumes pipx is installed, check poetry docs for other installation options.

  Linux:
  ```bash
  python3 -m pip install --user pipx
  python3 -m pipx ensurepath
  ```
  Windows:
  ```bash
  python -m pip install --user pipx

  ```
  Mac:
  ```bash
  brew install pipx
  pipx ensurepath
  ```


  For options other than pipx see [poetry documentation](https://python-poetry.org/docs/main/#installation)
  Open a new terminal/tab then
  ```bash
  pipx install poetry
  ```
  Let Poetry install all dependencies for you.
  ```bash
  poetry install
  ```
  If you're in a Linux environment add the extra Ert dependencies!
  ```bash
  poetry install -E ert
  ```

  Activate poetryenv (or use venv if that is more familiar, poetry should respect it as an environment):
  ```bash
  poetry shell
  ```

  Now you should be able to check that everything is installed correctly by running
  ```bash
  pytest
  ```
  in the activated poetry shell.

  Information regarding integration with PyCharm can be found here: https://www.jetbrains.com/help/pycharm/poetry.html#poetry-env
  More info on viewing your environment information can be found here: https://python-poetry.org/docs/managing-environments/#switching-between-environments

  Poetry support completion scripts for Bash, Fish and Zsh [detailed information can be found here](https://python-poetry.org/docs/#installing-with-pipx).



  This project makes use of pre-commit to ensure commits adhere to certain rules and standards.
  Pre-commit should already be installed in the `poetry install` command, but you need to activate the hooks like so:
  ```bash
  pre-commit install
  ```

  If for some reason this is not working correctly you can install pre-commit separately like this:
  ```bash
  pipx install pre-commit
  pre-commit install
  ```

  Now pre-commit should be a constant nuisance, bothering you with some minor change each time you want to commit.
  Although annoying this is preferable to having lots of minor quirks in the code, such as trailing whitespace everywhere.
  Just run git commit a second time, remembering to add the changes made by pre-commit and you should be mostly good!

  > Git hook scripts are useful for identifying simple issues before submission to code review.
  > Run hooks on every commit to automatically point out issues in code such as missing semicolons, trailing whitespace, and debug statements.
  > By pointing these issues out before code review, this allows a code reviewer to focus on the architecture of a change while not wasting time with trivial style nitpicks.
  > Black will style your code automatically to match the Black code style, and Flake8 will check your code for style, syntax, and logical errors.
  > Remember to add the changes made by the scripts to your commit.



  This project uses [pytest](https://docs.pytest.org/en/stable/) for unit and integration testing.
  Run it before every push to make sure your code is working as intended.
  To run all tests discovered by pytest, run the following command when in the root folder

  Recommended settings/launch args:
  This makes the tests run in parallel and in turn go a bit more brrrr.
  ```bash
  pytest -n auto
  ```


  This project make use of [Release Please](https://github.com/googleapis/release-please) to keep track of versioning.
  By following [conventional commit messages](https://www.conventionalcommits.org/en) (enforced) in PR titles, and squash-merging, the release please workflow will automatically create/update release-PRs based on which change is performed.


  This project uses [Black](https://pypi.org/project/black/) and [Flake8](https://pypi.org/project/flake8/) for code formatting and linting.
  It deviates from the default black config by setting the max line length to 120 characters.

  It might be helpful turn on format-on-save, and make black format your code on save.

  A helpful visual aid is to set rulers in your editor to 120 characters.
  Code should not exceed 120 characters.
  Add this to you `settings.json` to set rulers in VSCode:

  ```json
  {
    "editor.rulers": [
      120
    ],
    "workbench.colorCustomizations": {
      "editorRuler.foreground": "#33779944"
    }
  }
  ```


pkgId: 20ff06dfb98f92dc0284b3ba76668c07a5fb01f22be9004c26ecfe888d6239f7
name: python-complex-mathematics
arch: src
version: 4.17.10
epoch: 0
release: 1
summary: Many complex math features.
url: https://github.com/Arnav-MaIhotra/complex_mathematics
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-complex-mathematics-4.17.10-1.src.rpm
checksum_type: sha256
description:
  Many advanced math features and topics like linear algebra, geometry, calculus, algebra, and machine learning algorithms.


pkgId: 296714e51b3c6f6add49c6356c5b5c2102d1268f3249a404b78e74d9ef85b6d7
name: python-complexeva
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/complexeva/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-complexeva-0.1.14-1.src.rpm
checksum_type: sha256
description:
  computing fractal dimensions (and other complexity measures) and complexity measures in networks and matrices. The package includes:


  - Box-counting fractal dimension calculation for networks and matrices
  - Higuchi fractal dimension implementation
  - Network-to-matrix and image-to-matrix conversions
  - Dummy fractal generators for testing


pkgId: 28654405314284a2bdf454171b9c3a76be82330f1b3b139c4885464e76e7d25f
name: python-complexifier
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A library to make data worse
url: https://github.com/ruyzambrano/complexifier
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-complexifier-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This makes your pandas dataframe even worse



  ```sh
  pip install complexifier
  ```



  `introduce_spag_error`
  `add_or_subtract_outliers`
  `add_standard_deviations`
  `duplicate_rows`
  `add_nulls`


pkgId: 860b8fe8cfca0ae63fcaf3f4df68a3bd8e69258000a6f02bf38a2443072c688c
name: python-complexifier
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A library to make data worse
url: https://github.com/ruyzambrano/complexifier
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-complexifier-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This makes your pandas dataframe even worse



  - `pandas`
  - `typo`
  - `random`



  `complexifier` can be installed using `pip`

  ```sh
  pip install complexifier
  ```



  Once installed you can use `complexifier` to add mistakes and outliers to your data

  This library has several methods available:



  **Parameters**:
  - `word` (str): The original word to potentially alter.

  Introduces a 10% chance of a random spelling error in a given word. This function is useful for simulating typos and spelling mistakes in text data.



  Applies the create_spag_error function to each string entry in specified columns of a DataFrame, introducing random spelling errors with a 10% probability.

  **Parameters**:
  - `df` (pd.DataFrame): The DataFrame to alter.
  - `columns` (list or str): Column names to apply errors to. Defaults to all string columns.



  Randomly adds or subtracts values in specified numeric columns at random indices, simulating outliers between 1% and 10% of the rows.

  **Parameters**:
  - `df` (pd.DataFrame): The DataFrame to modify.
  - `columns` (list or str): Column names to adjust. Defaults to all numeric columns if not specified.



  Adds between 1 to 5 standard deviations to random entries in specified numeric columns to simulate data anomalies.

  **Parameters**:
  - `df` (pd.DataFrame): The DataFrame to manipulate.
  - `columns` (list or str): Column names to modify. Defaults to numeric columns if not specified.
  - `min_std` (int): Minimum number of standard deviations to add. Defaults to 1
  - `max_std` (int): Maximum number of standard deviations to add. Defaults to 5



  Introduces duplicate rows into a DataFrame. This function is useful for testing deduplication processes.

  **Parameters**:
  - `df` (pd.DataFrame): DataFrame to which duplicates will be added.
  - `sample_size` (int): number of rows to duplicate. A random percentage between 1% and 10% if not specified.



  Inserts null values into specified DataFrame columns. This simulates missing data conditions.

  **Parameters**:
  - `df` (pd.DataFrame): The DataFrame to modify.
  - `columns` (list or str, optional): Specific columns to add nulls to. Defaults to all columns if not specified.
  - `min_percent` (int): Minimum percentage of null values to insert. Defaults to 1%
  - `max_percent` (int): Maximum percentage of null values to insert. Defaults to 10%



  Adds all (or some) of the above methods. Really messes it up.

  **Parameters**:
  - `df` (pd.DataFrame): The DataFrame to modify.
  - `columns` (list or str, optional): Specific columns to add nulls to. Defaults to all columns if not specified.
  - `min_std` (int): Minimum number of standard deviations to add. Defaults to 1
  - `max_std` (int): Maximum number of standard deviations to add. Defaults to 5
  - `sample_size` (int, optional): Number of rows to duplicate. Randomly selected if not specified.
  - `min_percent` (int): Minimum percentage of null values to insert. Defaults to 1%
  - `max_percent` (int): Maximum percentage of null values to insert. Defaults to 10%
  - `introduce_spag` (bool): Adds spelling and grammar errors into string data. Defaults to True
  - `add_outliers` (bool): Adds outliers to numerical data. Defaults to True
  - `add_std` (bool): Adds standard deviations to the data. Defaults to True
  - `duplicate` (bool): Adds duplicate rows to the data. Defaults to True
  - `add_null` (bool): Adds null values to the dataset. Defaults to True


pkgId: b2100cf95f39b85efb477ac5a01c797f49bb89075971162ca1668897d6ee20c6
name: python-compliance-trestle
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: Tools to manage & autogenerate python objects representing the OSCAL layers/models
url: https://oscal-compass.github.io/compliance-trestle
rpm_license: Apache Software License v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compliance-trestle-3.4.0-1.src.rpm
checksum_type: sha256
description:
  ![[OS Compatibility](#prerequisites)](https://img.shields.io/badge/platform-osx%20%7C%20linux%20%7C%20windows-orange.svg)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compliance-trestle)
  ![[Pre-commit](https://github.com/pre-commit/pre-commit)](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)
  ![[Code Coverage](https://sonarcloud.io/dashboard?id=compliance-trestle)](https://sonarcloud.io/api/project_badges/measure?project=compliance-trestle&metric=coverage)
  ![[Quality gate](https://sonarcloud.io/dashboard?id=compliance-trestle)](https://sonarcloud.io/api/project_badges/measure?project=compliance-trestle&metric=alert_status)
  ![[Pypi](https://pypi.org/project/compliance-trestle/)](https://img.shields.io/pypi/dm/compliance-trestle)
  ![GitHub Actions status](https://img.shields.io/github/workflow/status/oscal-compass/compliance-trestle/Trestle%20PR%20pipeline?event=push)

  Trestle is an ensemble of tools that enable the creation, validation, and governance of documentation artifacts for compliance needs. It leverages NIST's [OSCAL](https://pages.nist.gov/OSCAL/) as a standard data format for interchange between tools and people, and provides an opinionated approach to OSCAL adoption.

  Trestle is designed to operate as a CICD pipeline running on top of compliance artifacts in `git`, to provide transparency for the state of compliance across multiple stakeholders in an environment friendly to developers. Trestle passes the generated artifacts onto tools that orchestrate the enforcement, measurement, and reporting of compliance.

  It also provides tooling to manage OSCAL documents in a more human-friendly manner. By splitting large OSCAL data structures into smaller and easier to edit sub-structures, creation and maintenance of these artifacts can follow normal `git` workflows including peer review via pull request, versioning, releases/tagging.

  Trestle provides three separate but related functions in the compliance space:

  - Manage OSCAL documents to allow editing and manipulation while making sure the schemas are enforced
  - Transform documents from other formats to OSCAL
  - Provide support and governance to author compliance content as markdown and drawio.

  Trestle provides tooling to help orchestrate the compliance process across a number of dimensions:

  - Help manage OSCAL documents in a more human-friendly manner by expanding the large OSCAL data structures into smaller and easier to edit sub-structures while making sure the schemas are enforced.
  - Transform documents from other formats to OSCAL
  - Provide governance for markdown documents and enforce consistency of format and content based on specified templates
  - Tooling manage authoring and governance of markdown and drawio files within a repository.
  - Support within trestle to streamline management within a managed git environment.
  - An underlying object model that supports developers interacting with OSCAL artifacts.



  Compliance suffers from being a complex topic that is hard to articulate simply. It involves complete and accurate execution of multiple procedures across many disciplines (e.g. IT, HR, management) with periodic verification and audit of those procedures against controls.

  While it is possible to manage the description of controls and how an organisation implements them in ad hoc ways with general tools (spreadsheets, documents), this is hard to maintain for multiple accreditations and, in the IT domain at least, creates a barrier between the compliance efforts and the people doing daily work (DevOps staff).

  Trestle aims to reduce or remove this barrier by bringing the maintenance of control descriptions into the DevOps domain. The goal is to have changes to the system (for example, updates to configuration management) easily related to the controls impacted, and to enable modification of those controls as required in concert with the system changes.

  Trestle implicitly provides a core opinionated workflow driven by its pipeline to allow standardized interlocks with other compliance tooling platforms.



  Compliance activities at scale, whether size of estate or number of accreditations, require automation to be successful and repeatable. OSCAL as a standard allows teams to bridge between the "Governance" layer and operational tools.

  By building human managed artifacts into OSCAL, Trestle is not only able to validate the integrity of the artifacts that people generate - it also enables reuse and sharing of artifacts, and furthermore can provide suitable input into tools that automate operational compliance.



  `trestle` implicitly supports all OSCAL schemas for use within the object model. The development roadmap for `trestle` includes adding workflow around specific elements / objects that is opinionated.



  OSCAL supports `xml`, `json` and `yaml` with their [metaschema](https://github.com/usnistgov/metaschema) tooling. Trestle
  natively supports only `json` and `yaml` formats at this time.

  Future roadmap anticipates that support for xml [import](https://github.com/oscal-compass/compliance-trestle/issues/177) and [upstream references](https://github.com/oscal-compass/compliance-trestle/issues/178) will be enabled. However, it is expected
  that full support will remain only for `json` and  `yaml`.

  Users needing to import XML OSCAL artifacts are recommended to look at NIST's XML to json conversion page [here](https://github.com/usnistgov/OSCAL/blob/main/build/README.md#converters).



  Trestle runs on almost all Python platforms (e.g. Linux, Mac, Windows), is available on PyPi and can be easily installed via pip. It is under active development and new releases are made available regularly.\
  To install run: `pip install compliance-trestle`\
  See [Install trestle in a python virtual environment](https://oscal-compass.github.io/compliance-trestle/python_trestle_setup/) for the full installation guide.



  Complete documentation, tutorials, and background on compliance can be found [here](https://oscal-compass.github.io/compliance-trestle).



  A trestle-based agile authoring repository setup tool, documentation and tutorial can be found [here](https://github.com/oscal-compass/compliance-trestle-agile-authoring).

  Agile authoring comprises the following beneficial features:

  - based on OSCAL documents behind-the-scenes
  - employs GIT for document control and access
  - exposes text (markdown) and spread sheets (csv) to ease management of compliance artifacts
  - implements compliance digitization for improved audit readiness and cost effectiveness



  A collection of demos utilizing trestle can be found in the related project [compliance-trestle-demos](https://github.com/oscal-compass/compliance-trestle-demos).





  - supports NIST OSCAL 1.1.2 as well as previous versions



  - supports NIST OSCAL 1.0.4 as well as previous versions



  Please refer to the community [README](https://github.com/oscal-compass/community/blob/main/README.md) for communication details.



  Our project welcomes external contributions. Please consult [contributing](https://oscal-compass.github.io/compliance-trestle/contributing/mkdocs_contributing/) to get started.



  Participation in the OSCAL Compass community is governed by the [Code of Conduct](https://github.com/oscal-compass/community/blob/main/CODE_OF_CONDUCT.md).



  If you would like to see the detailed LICENSE click [here](LICENSE).
  Consult [contributors](https://github.com/oscal-compass/compliance-trestle/graphs/contributors) for a list of authors and [maintainers](MAINTAINERS.md) for the core team.

  ```text














  ```


pkgId: 40041df98e0a2069bddeb1697d451f20ac6b60681a0f4592e7d5613631f693b4
name: python-compliance-trestle
arch: src
version: 3.5.0
epoch: 0
release: 1
summary: Tools to manage & autogenerate python objects representing the OSCAL layers/models
url: https://oscal-compass.github.io/compliance-trestle
rpm_license: Apache Software License v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-compliance-trestle-3.5.0-1.src.rpm
checksum_type: sha256
description:
  ![[OS Compatibility](#prerequisites)](https://img.shields.io/badge/platform-osx%20%7C%20linux%20%7C%20windows-orange.svg)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/compliance-trestle)
  ![[Pre-commit](https://github.com/pre-commit/pre-commit)](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)
  ![[Code Coverage](https://sonarcloud.io/dashboard?id=compliance-trestle)](https://sonarcloud.io/api/project_badges/measure?project=compliance-trestle&metric=coverage)
  ![[Quality gate](https://sonarcloud.io/dashboard?id=compliance-trestle)](https://sonarcloud.io/api/project_badges/measure?project=compliance-trestle&metric=alert_status)
  ![[Pypi](https://pypi.org/project/compliance-trestle/)](https://img.shields.io/pypi/dm/compliance-trestle)
  ![GitHub Actions status](https://github.com/oscal-compass/compliance-trestle/actions/workflows/python-test.yml/badge.svg?branch=develop)

  Trestle is an ensemble of tools that enable the creation, validation, and governance of documentation artifacts for compliance needs. It leverages NIST's [OSCAL](https://pages.nist.gov/OSCAL/) as a standard data format for interchange between tools and people, and provides an opinionated approach to OSCAL adoption.

  Trestle is designed to operate as a CICD pipeline running on top of compliance artifacts in `git`, to provide transparency for the state of compliance across multiple stakeholders in an environment friendly to developers. Trestle passes the generated artifacts onto tools that orchestrate the enforcement, measurement, and reporting of compliance.

  It also provides tooling to manage OSCAL documents in a more human-friendly manner. By splitting large OSCAL data structures into smaller and easier to edit sub-structures, creation and maintenance of these artifacts can follow normal `git` workflows including peer review via pull request, versioning, releases/tagging.

  Trestle provides three separate but related functions in the compliance space:

  - Manage OSCAL documents to allow editing and manipulation while making sure the schemas are enforced
  - Transform documents from other formats to OSCAL
  - Provide support and governance to author compliance content as markdown and drawio.

  Trestle provides tooling to help orchestrate the compliance process across a number of dimensions:

  - Help manage OSCAL documents in a more human-friendly manner by expanding the large OSCAL data structures into smaller and easier to edit sub-structures while making sure the schemas are enforced.
  - Transform documents from other formats to OSCAL
  - Provide governance for markdown documents and enforce consistency of format and content based on specified templates
  - Tooling manage authoring and governance of markdown and drawio files within a repository.
  - Support within trestle to streamline management within a managed git environment.
  - An underlying object model that supports developers interacting with OSCAL artifacts.



  Compliance suffers from being a complex topic that is hard to articulate simply. It involves complete and accurate execution of multiple procedures across many disciplines (e.g. IT, HR, management) with periodic verification and audit of those procedures against controls.

  While it is possible to manage the description of controls and how an organisation implements them in ad hoc ways with general tools (spreadsheets, documents), this is hard to maintain for multiple accreditations and, in the IT domain at least, creates a barrier between the compliance efforts and the people doing daily work (DevOps staff).

  Trestle aims to reduce or remove this barrier by bringing the maintenance of control descriptions into the DevOps domain. The goal is to have changes to the system (for example, updates to configuration management) easily related to the controls impacted, and to enable modification of those controls as required in concert with the system changes.

  Trestle implicitly provides a core opinionated workflow driven by its pipeline to allow standardized interlocks with other compliance tooling platforms.



  Compliance activities at scale, whether size of estate or number of accreditations, require automation to be successful and repeatable. OSCAL as a standard allows teams to bridge between the "Governance" layer and operational tools.

  By building human managed artifacts into OSCAL, Trestle is not only able to validate the integrity of the artifacts that people generate - it also enables reuse and sharing of artifacts, and furthermore can provide suitable input into tools that automate operational compliance.



  `trestle` implicitly supports all OSCAL schemas for use within the object model. The development roadmap for `trestle` includes adding workflow around specific elements / objects that is opinionated.



  OSCAL supports `xml`, `json` and `yaml` with their [metaschema](https://github.com/usnistgov/metaschema) tooling. Trestle
  natively supports only `json` and `yaml` formats at this time.

  Future roadmap anticipates that support for xml [import](https://github.com/oscal-compass/compliance-trestle/issues/177) and [upstream references](https://github.com/oscal-compass/compliance-trestle/issues/178) will be enabled. However, it is expected
  that full support will remain only for `json` and  `yaml`.

  Users needing to import XML OSCAL artifacts are recommended to look at NIST's XML to json conversion page [here](https://github.com/usnistgov/OSCAL/blob/main/build/README.md#converters).



  Trestle runs on almost all Python platforms (e.g. Linux, Mac, Windows), is available on PyPi and can be easily installed via pip. It is under active development and new releases are made available regularly.\
  To install run: `pip install compliance-trestle`\
  See [Install trestle in a python virtual environment](https://oscal-compass.github.io/compliance-trestle/python_trestle_setup/) for the full installation guide.



  Complete documentation, tutorials, and background on compliance can be found [here](https://oscal-compass.github.io/compliance-trestle).



  A trestle-based agile authoring repository setup tool, documentation and tutorial can be found [here](https://github.com/oscal-compass/compliance-trestle-agile-authoring).

  Agile authoring comprises the following beneficial features:

  - based on OSCAL documents behind-the-scenes
  - employs GIT for document control and access
  - exposes text (markdown) and spread sheets (csv) to ease management of compliance artifacts
  - implements compliance digitization for improved audit readiness and cost effectiveness



  A collection of demos utilizing trestle can be found in the related project [compliance-trestle-demos](https://github.com/oscal-compass/compliance-trestle-demos).





  - supports NIST OSCAL 1.1.2 as well as previous versions



  - supports NIST OSCAL 1.0.4 as well as previous versions



  Please refer to the community [README](https://github.com/oscal-compass/community/blob/main/README.md) for communication details.



  Our project welcomes external contributions. Please consult [contributing](https://oscal-compass.github.io/compliance-trestle/contributing/mkdocs_contributing/) to get started.



  Participation in the OSCAL Compass community is governed by the [Code of Conduct](https://github.com/oscal-compass/community/blob/main/CODE_OF_CONDUCT.md).



  If you would like to see the detailed LICENSE click [here](LICENSE).
  Consult [contributors](https://github.com/oscal-compass/compliance-trestle/graphs/contributors) for a list of authors and [maintainers](MAINTAINERS.md) for the core team.

  ```text













  ```

  ______________________________________________________________________

  We are a Cloud Native Computing Foundation sandbox project.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://www.cncf.io/wp-content/uploads/2022/07/cncf-white-logo.svg">
    <img src="https://www.cncf.io/wp-content/uploads/2022/07/cncf-color-bg.svg" width=300 />
  </picture>

  The Linux Foundation® (TLF) has registered trademarks and uses trademarks. For a list of TLF trademarks, see [Trademark Usage](https://www.linuxfoundation.org/legal/trademark-usage)".

  *Trestle was originally created by IBM.*


